Use coercions in more places to match rust

noir-lang · Jul 28, 2023 · 752ae8e · 752ae8e
1 parent 0bfa557
commit 752ae8e
Show file tree

Hide file tree

Showing 3 changed files with 19 additions and 9 deletions.
diff --git a/crates/noirc_frontend/src/hir/type_check/expr.rs b/crates/noirc_frontend/src/hir/type_check/expr.rs
@@ -504,7 +504,7 @@ impl<'interner> TypeChecker<'interner> {
                 let arg_type = self.check_expression(&arg);
 
                 let span = self.interner.expr_span(expr_id);
-                self.make_subtype_of(&arg_type, &param_type, span, || {
+                self.make_subtype_of(&arg_type, &param_type, arg, || {
                     TypeCheckError::TypeMismatch {
                         expected_typ: param_type.to_string(),
                         expr_typ: arg_type.to_string(),

diff --git a/crates/noirc_frontend/src/hir/type_check/mod.rs b/crates/noirc_frontend/src/hir/type_check/mod.rs
@@ -63,13 +63,17 @@ pub fn type_check_func(interner: &mut NodeInterner, func_id: FuncId) -> Vec<Type
     // Check declared return type and actual return type
     if !can_ignore_ret {
         let func_span = interner.expr_span(function_body_id); // XXX: We could be more specific and return the span of the last stmt, however stmts do not have spans yet
-        function_last_type.make_subtype_of(&declared_return_type, func_span, &mut errors, || {
-            TypeCheckError::TypeMismatch {
+        function_last_type.make_subtype_with_coercions(
+            &declared_return_type,
+            *function_body_id,
+            interner,
+            &mut errors,
+            || TypeCheckError::TypeMismatch {
                 expected_typ: declared_return_type.to_string(),
                 expr_typ: function_last_type.to_string(),
                 expr_span: func_span,
-            }
-        });
+            },
+        );
     }
 
     errors
@@ -130,10 +134,16 @@ impl<'interner> TypeChecker<'interner> {
         &mut self,
         actual: &Type,
         expected: &Type,
-        span: Span,
+        expression: ExprId,
         make_error: impl FnOnce() -> TypeCheckError,
     ) {
-        actual.make_subtype_of(expected, span, &mut self.errors, make_error);
+        actual.make_subtype_with_coercions(
+            expected,
+            expression,
+            self.interner,
+            &mut self.errors,
+            make_error,
+        );
     }
 }
 

diff --git a/crates/noirc_frontend/src/hir/type_check/stmt.rs b/crates/noirc_frontend/src/hir/type_check/stmt.rs
@@ -108,7 +108,7 @@ impl<'interner> TypeChecker<'interner> {
         });
 
         let span = self.interner.expr_span(&assign_stmt.expression);
-        self.make_subtype_of(&expr_type, &lvalue_type, span, || {
+        self.make_subtype_of(&expr_type, &lvalue_type, assign_stmt.expression, || {
             TypeCheckError::TypeMismatchWithSource {
                 rhs: expr_type.clone(),
                 lhs: lvalue_type.clone(),
@@ -259,7 +259,7 @@ impl<'interner> TypeChecker<'interner> {
             // Now check if LHS is the same type as the RHS
             // Importantly, we do not coerce any types implicitly
             let expr_span = self.interner.expr_span(&rhs_expr);
-            self.make_subtype_of(&expr_type, &annotated_type, expr_span, || {
+            self.make_subtype_of(&expr_type, &annotated_type, rhs_expr, || {
                 TypeCheckError::TypeMismatch {
                     expected_typ: annotated_type.to_string(),
                     expr_typ: expr_type.to_string(),