reid-llvm-lib/src/builder.rs

@@ -385,12 +385,10 @@ impl Builder {
                 }
                 Instr::FunctionCall(fun, params) => {
                     let param_types = self.function_data(&fun).params;
-                    dbg!(&params, &param_types);
                     if param_types.len() != params.len() {
                         return Err(()); // TODO error: invalid amount of params
                     }
                     for (a, b) in param_types.iter().zip(params) {
-                        dbg!(b.get_type(&self)?);
                         if *a != b.get_type(&self)? {
                             return Err(()); // TODO error: params do not match
                         }

reid/src/mir/implement.rs

@@ -542,7 +542,7 @@ pub fn pick_return<T>(lhs: (ReturnKind, T), rhs: (ReturnKind, T)) -> (ReturnKind
 impl TypeKind {
     /// Assert that a type is already known and not vague. Return said type or
     /// error.
-    pub fn assert_unvague(&self) -> Result<TypeKind, ErrorKind> {
+    pub fn assert_known(&self) -> Result<TypeKind, ErrorKind> {
         self.known().map_err(ErrorKind::TypeIsVague)
     }
 

reid/src/mir/typecheck.rs

@@ -89,7 +89,7 @@ impl<'t> Pass for TypeCheck<'t> {
                 name,
                 kind,
                 meta,
-                source_module: _,
+                source_module,
             } = &typedef;
 
             match kind {
@@ -162,12 +162,12 @@ fn check_typedefs_for_recursion<'a, 'b>(
 impl FunctionDefinition {
     fn typecheck(
         &mut self,
-        typerefs: &TypeRefs,
+        hints: &TypeRefs,
         state: &mut TypecheckPassState,
     ) -> Result<TypeKind, ErrorKind> {
         for param in &self.parameters {
             let param_t = state.or_else(
-                param.1.assert_known(typerefs, state),
+                param.1.assert_known(),
                 TypeKind::Vague(Vague::Unknown),
                 self.signature(),
             );
@@ -185,11 +185,11 @@ impl FunctionDefinition {
             state.ok(res, self.signature());
         }
 
-        let return_type = self.return_type.clone().assert_known(typerefs, state)?;
+        let return_type = self.return_type.clone();
         let inferred = match &mut self.kind {
             FunctionDefinitionKind::Local(block, _) => {
                 state.scope.return_type_hint = Some(self.return_type.clone());
-                block.typecheck(&mut state.inner(), &typerefs, Some(&return_type))
+                block.typecheck(&mut state.inner(), &hints, Some(&return_type))
             }
             FunctionDefinitionKind::Extern(_) => {
                 Ok((ReturnKind::Soft, TypeKind::Vague(Vague::Unknown)))
@@ -408,7 +408,7 @@ impl Expression {
             ExprKind::BinOp(op, lhs, rhs) => {
                 // TODO make sure lhs and rhs can actually do this binary
                 // operation once relevant
-                let lhs_res = lhs.typecheck(state, &typerefs, hint_t);
+                let lhs_res = lhs.typecheck(state, &typerefs, None);
                 let lhs_type = state.or_else(lhs_res, TypeKind::Vague(Vague::Unknown), lhs.1);
                 let rhs_res = rhs.typecheck(state, &typerefs, Some(&lhs_type));
                 let rhs_type = state.or_else(rhs_res, TypeKind::Vague(Vague::Unknown), rhs.1);
@@ -755,33 +755,3 @@ impl Literal {
         }
     }
 }
-
-impl TypeKind {
-    fn assert_known(
-        &self,
-        refs: &TypeRefs,
-        state: &TypecheckPassState,
-    ) -> Result<TypeKind, ErrorKind> {
-        self.is_known(refs, state).map(|_| self.clone())
-    }
-
-    fn is_known(&self, refs: &TypeRefs, state: &TypecheckPassState) -> Result<(), ErrorKind> {
-        match &self {
-            TypeKind::Array(type_kind, _) => type_kind.as_ref().is_known(refs, state),
-            TypeKind::CustomType(custom_type_key) => state
-                .scope
-                .types
-                .get(custom_type_key)
-                .map(|_| ())
-                .ok_or(ErrorKind::NoSuchType(
-                    custom_type_key.0.clone(),
-                    state.module_id.unwrap(),
-                )),
-            TypeKind::Borrow(type_kind, _) => type_kind.is_known(refs, state),
-            TypeKind::UserPtr(type_kind) => type_kind.is_known(refs, state),
-            TypeKind::CodegenPtr(type_kind) => type_kind.is_known(refs, state),
-            TypeKind::Vague(vague_type) => Err(ErrorKind::TypeIsVague(*vague_type)),
-            _ => Ok(()),
-        }
-    }
-}

reid/src/mir/typeinference.rs

@@ -49,7 +49,7 @@ impl FunctionDefinition {
     ) -> Result<(), ErrorKind> {
         let scope_hints = ScopeTypeRefs::from(type_refs);
         for param in &self.parameters {
-            let param_t = state.or_else(param.1.assert_unvague(), Vague(Unknown), self.signature());
+            let param_t = state.or_else(param.1.assert_known(), Vague(Unknown), self.signature());
             let res = scope_hints
                 .new_var(param.0.clone(), false, &param_t)
                 .or(Err(ErrorKind::VariableAlreadyDefined(param.0.clone())));

reid_src/test.reid

@@ -1,12 +0,0 @@
-fn vec_sub(l: [f32; 3], r: [f32; 3]) -> [f32; 3] {
-    return [l[0]-r[0], l[1]-r[1], l[2]-r[2]];
-}
-
-fn foo(x: f32) {
-    let a = [x, x, 0.0];
-    let b = [x, x, x]; // works
-    // let b = [x * 0.5, x * 0.5, x]; // does not work
-    vec_sub(a, b);
-}
-
-fn main() {}