Merge BlockstreamResearch#68: Bug fixes

27a31f3 fix: Broken intra-doc link (Christian Lewe)
3c4ead4 fix: Nonempty returns require nonempty bodies (Christian Lewe)
1d9d545 test: Add example using options (Christian Lewe)
26c36d0 fix: Compile empty option using injl (Christian Lewe)
f5b12ee fix: Analyze assigned expr before bound variables (Christian Lewe)

Pull request description:

  Fixes some bugs I found while playing around with the web IDE.

ACKs for top commit:
  apoelstra:
    ACK 27a31f3

Tree-SHA512: 5b2950e3dedf393e48184cd6d13a7ad4fa23b4fb43a2f892f0c0a659c2d37d8c82ad32bbda2e45a160a45e58208c215e46d85b1d075e2c7798380979df4c9b21

Author: uncomputable

example_progs/option.simf

@@ -0,0 +1,11 @@
+fn checked_div_32(x: u32, y: u32) -> Option<u32> {
+    match jet_is_zero_32(y) {
+        true  => None,
+        false => Some(jet_divide_32(x, y)),
+    }
+}
+
+fn main() {
+    let res: Option<u32> = checked_div_32(10, 3);
+    jet_verify(jet_eq_32(3, unwrap(res)));
+}

src/ast.rs

@@ -634,11 +634,11 @@ impl AbstractSyntaxTree for Assignment {
         // However, the expression evaluated in the assignment does have a type,
         // namely the type specified in the assignment.
         let ty_expr = scope.resolve(&from.ty).with_span(from)?;
+        let expression = Expression::analyze(&from.expression, &ty_expr, scope)?;
         let typed_variables = from.pattern.is_of_type(&ty_expr).with_span(from)?;
         for (identifier, ty) in typed_variables {
             scope.insert_variable(identifier, ty);
         }
-        let expression = Expression::analyze(&from.expression, &ty_expr, scope)?;
 
         Ok(Self {
             pattern: from.pattern.clone(),
@@ -667,10 +667,17 @@ impl AbstractSyntaxTree for Expression {
                     .iter()
                     .map(|s| Statement::analyze(s, &ResolvedType::unit(), scope))
                     .collect::<Result<Arc<[Statement]>, RichError>>()?;
-                let ast_expression = expression
-                    .as_ref()
-                    .map(|expr| Expression::analyze(expr, ty, scope).map(Arc::new))
-                    .transpose()?;
+                let ast_expression = match expression {
+                    Some(expression) => Expression::analyze(expression, ty, scope)
+                        .map(Arc::new)
+                        .map(Some),
+                    None if ty.is_unit() => Ok(None),
+                    None => Err(Error::ExpressionTypeMismatch(
+                        ty.clone(),
+                        ResolvedType::unit(),
+                    ))
+                    .with_span(from),
+                }?;
                 scope.pop_scope();
 
                 Ok(Self {

src/compile.rs

@@ -255,7 +255,7 @@ impl SingleExpression {
                     res_a.and_then(|a| res_b.and_then(|b| ProgNode::pair(&a, &b).with_span(self)))
                 })?
             }
-            SingleExpressionInner::Option(None) => ProgNode::injr(&ProgNode::unit()),
+            SingleExpressionInner::Option(None) => ProgNode::injl(&ProgNode::unit()),
             SingleExpressionInner::Either(Either::Left(inner)) => {
                 let compiled = inner.compile(scope)?;
                 ProgNode::injl(&compiled)

src/lib.rs

@@ -63,7 +63,6 @@ mod tests {
     #[test]
     fn test_progs() {
         for (prog_file, wit_file) in [
-            ("add.simf", "empty.wit"),
             ("add.simf", "empty.wit"),
             ("array.simf", "empty.wit"),
             ("cat.simf", "empty.wit"),
@@ -72,9 +71,11 @@ mod tests {
                 "checksigfromstackverify.wit",
             ),
             ("ctv.simf", "empty.wit"),
+            ("function.simf", "empty.wit"),
             ("list.simf", "empty.wit"),
             ("match.simf", "empty.wit"),
             ("nesting.simf", "empty.wit"),
+            ("option.simf", "empty.wit"),
             ("recursive-covenant.simf", "empty.wit"),
             ("scopes.simf", "empty.wit"),
             ("sighash_all.simf", "empty.wit"),
@@ -85,7 +86,6 @@ mod tests {
             ("sighash_none.simf", "sighash_none.wit"),
             ("tuple.simf", "empty.wit"),
             ("unwrap.simf", "empty.wit"),
-            ("function.simf", "empty.wit"),
         ] {
             _test_progs(prog_file, wit_file)
         }
@@ -107,7 +107,12 @@ mod tests {
                 panic!("{error}")
             }
         };
-        let redeem_prog = match satisfy(&prog_text, &witness) {
+
+        assert_success(&prog_text, &witness);
+    }
+
+    fn assert_success(prog_text: &str, witness: &WitnessValues) {
+        let redeem_prog = match satisfy(prog_text, witness) {
             Ok(x) => x,
             Err(error) => {
                 panic!("{error}");
@@ -120,10 +125,52 @@ mod tests {
         dbg!(&redeem_prog);
         println!("{}", Base64Display::new(&vec, &STANDARD));
 
-        let mut bit_mac = BitMachine::for_program(&redeem_prog);
+        let mut mac = BitMachine::for_program(&redeem_prog);
         let env = dummy_env::dummy();
-        bit_mac
-            .exec(&redeem_prog, &env)
+        mac.exec(&redeem_prog, &env)
             .expect("Machine execution failure");
     }
+
+    fn assert_success_empty_witness(prog_text: &str) {
+        let witness = WitnessValues::empty();
+        assert_success(prog_text, &witness)
+    }
+
+    fn assert_satisfy_error_empty_witness(prog_text: &str, expected_error: &str) {
+        let witness = WitnessValues::empty();
+        match satisfy(prog_text, &witness) {
+            Ok(_) => panic!("Accepted faulty program"),
+            Err(error) => {
+                if !error.contains(expected_error) {
+                    panic!("Unexpected error: {error}")
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn redefined_variable() {
+        let prog_text = r#"fn main() {
+    let beefbabe: (u16, u16) = (0xbeef, 0xbabe);
+    let beefbabe: u32 = <(u16, u16)>::into(beefbabe);
+}
+"#;
+        assert_success_empty_witness(prog_text);
+    }
+
+    #[test]
+    fn empty_function_body_nonempty_return() {
+        let prog_text = r#"fn my_true() -> bool {
+    // function body is empty, although function must return `bool`
+}
+
+fn main() {
+    jet_verify(my_true());
+}
+"#;
+        assert_satisfy_error_empty_witness(
+            prog_text,
+            "Expected expression of type `bool`, found type `()`",
+        );
+    }
 }

src/parse.rs

@@ -589,7 +589,7 @@ trait PestParse: Sized {
     fn parse(pair: pest::iterators::Pair<Rule>) -> Result<Self, RichError>;
 }
 
-/// Copy of [`std::std::FromStr`] that internally uses the PEST parser.
+/// Copy of [`FromStr`] that internally uses the PEST parser.
 pub trait ParseFromStr: Sized {
     /// Parse a value from the string `s`.
     fn parse_from_str(s: &str) -> Result<Self, RichError>;