[fine] Test for function return type mismatch

A function returns what it says it does, the check is that the body
returns the right value.

fine/build.rs

@@ -87,6 +87,11 @@ fn generate_test_for_file(path: PathBuf) -> String {
             assertions.push(quote! {
                 crate::assert_eval_ok(&_tree, &_lines, #expected);
             });
+        } else if let Some(line) = line.strip_prefix("@check-error:") {
+            let expected = line.trim();
+            assertions.push(quote! {
+                crate::assert_check_error(&_tree, &_lines, #expected);
+            });
         } else if line.starts_with("@") {
             panic!("Test file {display_path} has unknown directive: {line}");
         }

fine/src/semantics.rs

@@ -657,17 +657,13 @@ impl<'a> Semantics<'a> {
             TreeKind::Identifier => self.type_of_identifier(t, tree),
 
             TreeKind::FunctionDecl => self.type_of_function_decl(tree),
+            TreeKind::ReturnType => self.type_of_return_type(tree),
 
             _ => self.internal_compiler_error(Some(t), "asking for a nonsense type"),
         };
 
         // NOTE: These return `None` if they encounter some problem.
         let result = result.unwrap_or(Type::Error);
-
-        if result.is_error() {
-            eprintln!("OH NO AN ERROR AT {}: {:?}", t.index(), tree);
-        }
-
         self.types.borrow_mut()[t.index()] = Incremental::Complete(result.clone());
         result
     }
@@ -1021,6 +1017,11 @@ impl<'a> Semantics<'a> {
         Some(Type::Function(parameter_types, return_type))
     }
 
+    fn type_of_return_type(&self, tree: &Tree) -> Option<Type> {
+        assert_eq!(tree.kind, TreeKind::ReturnType);
+        Some(self.type_of(tree.nth_tree(1)?)) // type expression
+    }
+
     fn type_of_if_statement(&self, tree: &Tree) -> Option<Type> {
         Some(self.type_of(tree.nth_tree(0)?))
     }
@@ -1101,9 +1102,7 @@ pub fn check(s: &Semantics) {
         match tree.kind {
             TreeKind::Error => {} // already reported
             TreeKind::File => {}
-            TreeKind::FunctionDecl => {
+            TreeKind::FunctionDecl => check_function_decl(s, t, tree),
-                let _ = s.environment_of(t);
-            }
             TreeKind::ParamList => {}
             TreeKind::Parameter => {}
             TreeKind::TypeExpression => {
@@ -1138,6 +1137,38 @@ pub fn check(s: &Semantics) {
     }
 }
 
+fn check_function_decl(s: &Semantics, t: TreeRef, tree: &Tree) {
+    assert_eq!(tree.kind, TreeKind::FunctionDecl);
+    let _ = s.environment_of(t);
+
+    let return_type_tree = tree.child_of_kind(s.syntax_tree, TreeKind::ReturnType);
+    let return_type = return_type_tree
+        .map(|t| s.type_of(t))
+        .unwrap_or(Type::Nothing);
+
+    if let Some(body) = tree.child_of_kind(s.syntax_tree, TreeKind::Block) {
+        let body_type = s.type_of(body);
+        if !body_type.compatible_with(&return_type) {
+            // Just work very hard to get an appropriate error span.
+            let (start, end) = return_type_tree
+                .map(|t| {
+                    let rtt = &s.syntax_tree[t];
+                    (rtt.start_pos, rtt.end_pos)
+                })
+                .unwrap_or_else(|| {
+                    let start = tree.start_pos;
+                    let end_tok = tree
+                        .nth_token(1)
+                        .unwrap_or_else(|| tree.nth_token(0).unwrap());
+                    let end_pos = end_tok.start + end_tok.as_str().len();
+                    (start, end_pos)
+                });
+
+            s.report_error_span(start, end, format!("the body of this function yields a value of type `{body_type}`, but callers expect this function to produce a `{return_type}`"));
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

fine/tests/example_tests.rs

@@ -259,7 +259,6 @@ fn assert_no_errors(tree: &SyntaxTree, lines: &Lines) {
     );
 }
 
-#[allow(dead_code)]
 fn assert_eval_ok(tree: &SyntaxTree, lines: &Lines, expected: &str) {
     let semantics = Semantics::new(tree, lines);
 
@@ -284,4 +283,17 @@ fn assert_eval_ok(tree: &SyntaxTree, lines: &Lines, expected: &str) {
     }
 }
 
+fn assert_check_error(tree: &SyntaxTree, lines: &Lines, expected: &str) {
+    let semantics = Semantics::new(tree, lines);
+    check(&semantics);
+
+    let errors = semantics.snapshot_errors();
+    semantic_assert!(
+        &semantics,
+        None,
+        errors.iter().any(|e| e.message == expected),
+        "Unable to find the expected error message '{expected}'"
+    );
+}
+
 include!(concat!(env!("OUT_DIR"), "/generated_tests.rs"));

fine/tests/expression/argument.fine

@@ -1,8 +1,8 @@
-fun foo(x: f64) {
+fun foo(x: f64) -> f64 {
   x + 7
 }
 
-fun test() {
+fun test() -> f64 {
   foo(1)
 }
 
@@ -22,6 +22,10 @@ fun test() {
 // |         TypeExpression
 // |           Identifier:'"f64"'
 // |       RightParen:'")"'
+// |     ReturnType
+// |       Arrow:'"->"'
+// |       TypeExpression
+// |         Identifier:'"f64"'
 // |     Block
 // |       LeftBrace:'"{"'
 // |       ExpressionStatement
@@ -38,6 +42,10 @@ fun test() {
 // |     ParamList
 // |       LeftParen:'"("'
 // |       RightParen:'")"'
+// |     ReturnType
+// |       Arrow:'"->"'
+// |       TypeExpression
+// |         Identifier:'"f64"'
 // |     Block
 // |       LeftBrace:'"{"'
 // |       ExpressionStatement

fine/tests/expression/arithmetic.fine

@@ -1,4 +1,4 @@
-fun test() {
+fun test() -> f64 {
     1 * 2 + -3 * 4
 }
 
@@ -13,6 +13,10 @@ fun test() {
 // |     ParamList
 // |       LeftParen:'"("'
 // |       RightParen:'")"'
+// |     ReturnType
+// |       Arrow:'"->"'
+// |       TypeExpression
+// |         Identifier:'"f64"'
 // |     Block
 // |       LeftBrace:'"{"'
 // |       ExpressionStatement

fine/tests/expression/boolean.fine

@@ -1,4 +1,4 @@
-fun test() {
+fun test() -> bool {
     true and false or false and !true
 }
 
@@ -38,6 +38,10 @@ fun test() {
 // |     ParamList
 // |       LeftParen:'"("'
 // |       RightParen:'")"'
+// |     ReturnType
+// |       Arrow:'"->"'
+// |       TypeExpression
+// |         Identifier:'"bool"'
 // |     Block
 // |       LeftBrace:'"{"'
 // |       ExpressionStatement

fine/tests/expression/conditional.fine

@@ -1,22 +1,22 @@
-fun test() {
+fun test() -> f64 {
     if true { "discarded"; 23 } else { 45 }
 }
 
 // @no-errors
 // Here come some type probes!
 // (type of the condition)
-// @type: 20 bool
+// @type: 27 bool
 //
 // (the discarded expression)
-// @type: 27 string
+// @type: 34 string
 //
 // (the "then" clause)
-// @type: 40 f64
+// @type: 47 f64
-// @type: 43 f64
+// @type: 50 f64
 //
 // (the "else" clause)
-// @type: 52 f64
+// @type: 59 f64
-// @type: 55 f64
+// @type: 62 f64
 //
 // @concrete:
 // | File
@@ -26,6 +26,10 @@ fun test() {
 // |     ParamList
 // |       LeftParen:'"("'
 // |       RightParen:'")"'
+// |     ReturnType
+// |       Arrow:'"->"'
+// |       TypeExpression
+// |         Identifier:'"f64"'
 // |     Block
 // |       LeftBrace:'"{"'
 // |       IfStatement

fine/tests/expression/errors/return_type_mismatch.fine

@@ -0,0 +1,5 @@
+fun test() -> bool {
+  32
+}
+
+// @check-error: the body of this function yields a value of type `f64`, but callers expect this function to produce a `bool`