improved error messages for function-definitions

tests/snapshots/success_func_arr_return

@@ -1,8 +1,8 @@
 error: functions cannot return type 'int [2]'
-|  --> in tests/fixtures/func_arr_return.c:3:9
+|  --> in tests/fixtures/func_arr_return.c:3:5
 |
 3 arr some() {
-|         ^
+|     ^
 error: functions cannot return type 'int [2]'
 |  --> in tests/fixtures/func_arr_return.c:10:8
 |

wrecc_compiler/src/compiler/typechecker/mir/decl.rs

@@ -149,20 +149,8 @@ impl Function {
         }
         Ok(())
     }
-    pub fn main_return(&mut self, token: &Token, body: &mut Vec<Stmt>) -> Result<(), Error> {
+    pub fn implicit_main_return(&mut self, body: &mut Vec<Stmt>) {
         if self.name == "main" {
-            if self.return_type != Type::Primitive(Primitive::Int) {
-                return Err(Error::new(
-                    token,
-                    ErrorKind::InvalidMainReturn(self.return_type.clone()),
-                ));
-            }
-            if self.is_inline {
-                return Err(Error::new(
-                    token,
-                    ErrorKind::Regular("'main' function cannot be declared 'inline'"),
-                ));
-            }
             if !self.returns_all_paths {
                 self.returns_all_paths = true;
 
@@ -173,7 +161,6 @@ impl Function {
                 })));
             }
         }
-        Ok(())
     }
 }
 

wrecc_compiler/src/compiler/typechecker/mod.rs

@@ -964,7 +964,25 @@ impl TypeChecker {
             })?;
 
         if return_type.is_func() || return_type.is_array() {
-            return Err(Error::new(&token, ErrorKind::InvalidReturnType(return_type)));
+            return Err(Error::new(
+                &func_decl.name,
+                ErrorKind::InvalidReturnType(return_type),
+            ));
+        }
+
+        if name_string == "main" {
+            if return_type != Type::Primitive(Primitive::Int) {
+                return Err(Error::new(
+                    &func_decl.name,
+                    ErrorKind::InvalidMainReturn(return_type),
+                ));
+            }
+            if func_decl.is_inline {
+                return Err(Error::new(
+                    &func_decl.name,
+                    ErrorKind::Regular("'main' function cannot be declared 'inline'"),
+                ));
+            }
         }
 
         // have to push scope before declaring local variables
@@ -1010,27 +1028,35 @@ impl TypeChecker {
                 return Err(Error::new(&func_decl.name, ErrorKind::UnnamedFuncParams));
             }
         }
+        let mut errors = Vec::new();
+        let mut func_body = Vec::new();
 
-        // check function body
-        let body = self.block(&mut func, body);
-
-        func.compare_gotos()?;
+        match self.block(&mut func, body) {
+            Ok(mir::stmt::Stmt::Block(stmts)) => func_body = stmts,
+            Err(Error { kind: ErrorKind::Multiple(errs), .. }) => {
+                errors = errs;
+            }
+            _ => unreachable!(),
+        };
 
-        let mir::stmt::Stmt::Block(mut body) = body? else {unreachable!()};
+        if let Err(e) = func.compare_gotos() {
+            errors.push(e);
+        }
 
-        func.main_return(&func_decl.name, &mut body)?;
+        func.implicit_main_return(&mut func_body);
 
-        if !func.return_type.is_void() && !func.returns_all_paths {
+        if errors.is_empty() {
+            if !func.return_type.is_void() && !func.returns_all_paths {
+                return Err(Error::new(
+                    &func_decl.name,
+                    ErrorKind::NoReturnAllPaths(name_string),
+                ));
+            }
             func.returns_all_paths = false;
 
-            Err(Error::new(
-                &func_decl.name,
-                ErrorKind::NoReturnAllPaths(name_string),
-            ))
+            Ok(mir::decl::ExternalDeclaration::Function(func, symbol, func_body))
         } else {
-            func.returns_all_paths = false;
-
-            Ok(mir::decl::ExternalDeclaration::Function(func, symbol, body))
+            Err(Error::new_multiple(errors))
         }
     }
     fn visit_stmt(
@@ -2970,22 +2996,20 @@ int main(){
 inline static foo();
 inline int bar;
 
-void some(){
+int main() {
     extern inline char goo(inline some);
 
     inline char zoo();
     char zoo();
 
     typedef inline boo(void);
 }
-
-int inline main() {}
 ",
         )
         .unwrap_err();
 
         assert!(matches!(
-            dbg!(actual.as_slice()),
+            actual.as_slice(),
             &[
                 Error {
                     kind: ErrorKind::Regular(..),
@@ -3001,10 +3025,28 @@ int inline main() {}
                     kind: ErrorKind::Regular("'inline' not allowed with 'typedef' storage-class"),
                     ..
                 },
-                Error {
-                    kind: ErrorKind::Regular("'main' function cannot be declared 'inline'"),
-                    ..
-                },
+            ]
+        ));
+    }
+    #[test]
+    fn missing_goto() {
+        let actual = typecheck(
+            "
+int foo(){
+    char c = &1;
+    goto b;
+    int *p = c;
+}
+        ",
+        )
+        .unwrap_err();
+
+        assert!(matches!(
+            actual.as_slice(),
+            &[
+                Error { kind: ErrorKind::NotLvalue(..), .. },
+                Error { kind: ErrorKind::IllegalAssign(..), .. },
+                Error { kind: ErrorKind::UndeclaredLabel(..), .. },
             ]
         ));
     }