feat: better error message when trying to invoke struct function field

compiler/noirc_frontend/src/elaborator/types.rs

@@ -418,7 +418,7 @@
                 // TODO(https://github.com/noir-lang/noir/issues/6238):
                 // support non-u32 generics here
                 if !kind.unifies(&Kind::u32()) {
                     let error = TypeCheckError::EvaluatedGlobalIsntU32 {
                         expected_kind: Kind::u32().to_string(),
                         expr_kind: kind.to_string(),
                         expr_span: path.span(),
@@ -1321,11 +1321,23 @@
                 {
                     Some(method_id) => Some(HirMethodReference::FuncId(method_id)),
                     None => {
-                        self.push_err(TypeCheckError::UnresolvedMethodCall {
-                            method_name: method_name.to_string(),
-                            object_type: object_type.clone(),
-                            span,
-                        });
+                        let has_field_with_function_type =
+                            typ.borrow().get_fields_as_written().into_iter().any(|field| {
+                                field.name.0.contents == method_name && field.typ.is_function()
+                            });
+                        if has_field_with_function_type {
+                            self.push_err(TypeCheckError::CannotInvokeStructFieldFunctionType {
+                                method_name: method_name.to_string(),
+                                object_type: object_type.clone(),
+                                span,
+                            });
+                        } else {
+                            self.push_err(TypeCheckError::UnresolvedMethodCall {
+                                method_name: method_name.to_string(),
+                                object_type: object_type.clone(),
+                                span,
+                            });
+                        }
                         None
                     }
                 }

compiler/noirc_frontend/src/hir/type_check/errors.rs

@@ -68,7 +68,7 @@
     },
     // TODO(https://github.com/noir-lang/noir/issues/6238): implement handling for larger types
     #[error("Expected type {expected_kind} when evaluating globals, but found {expr_kind} (this warning may become an error in the future)")]
     EvaluatedGlobalIsntU32 { expected_kind: String, expr_kind: String, expr_span: Span },
     #[error("Expected {expected:?} found {found:?}")]
     ArityMisMatch { expected: usize, found: usize, span: Span },
     #[error("Return type in a function cannot be public")]
@@ -99,6 +99,8 @@
     CannotMutateImmutableVariable { name: String, span: Span },
     #[error("No method named '{method_name}' found for type '{object_type}'")]
     UnresolvedMethodCall { method_name: String, object_type: Type, span: Span },
+    #[error("Cannot invoke function field '{method_name}' on type '{object_type}' as a method")]
+    CannotInvokeStructFieldFunctionType { method_name: String, object_type: Type, span: Span },
     #[error("Integers must have the same signedness LHS is {sign_x:?}, RHS is {sign_y:?}")]
     IntegerSignedness { sign_x: Signedness, sign_y: Signedness, span: Span },
     #[error("Integers must have the same bit width LHS is {bit_width_x}, RHS is {bit_width_y}")]
@@ -273,7 +275,7 @@
             }
             // TODO(https://github.com/noir-lang/noir/issues/6238): implement
             // handling for larger types
             TypeCheckError::EvaluatedGlobalIsntU32 { expected_kind, expr_kind, expr_span } => {
                 Diagnostic::simple_warning(
                     format!("Expected type {expected_kind} when evaluating globals, but found {expr_kind} (this warning may become an error in the future)"),
                     String::new(),
@@ -511,6 +513,13 @@
             TypeCheckError::CyclicType { typ: _, span } => {
                 Diagnostic::simple_error(error.to_string(), "Cyclic types have unlimited size and are prohibited in Noir".into(), *span)
             }
+            TypeCheckError::CannotInvokeStructFieldFunctionType { method_name, object_type, span } => {
+                Diagnostic::simple_error(
+                    format!("Cannot invoke function field '{method_name}' on type '{object_type}' as a method"), 
+                    format!("to call the function stored in '{method_name}', surround the field access with parentheses: '(', ')'"),
+                    *span,
+                )
+            },
         }
     }
 }

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1087,6 +1087,14 @@
         }
     }
 
+    pub fn is_function(&self) -> bool {
+        match self.follow_bindings() {
+            Type::Function(..) => true,
+            Type::Alias(alias_type, _) => alias_type.borrow().typ.is_function(),
+            _ => false,
+        }
+    }
+
     /// True if this type can be used as a parameter to `main` or a contract function.
     /// This is only false for unsized types like slices or slices that do not make sense
     /// as a program input such as named generics or mutable references.
@@ -2138,7 +2146,7 @@
         }
 
         let recur_on_binding = |id, replacement: &Type| {
             // Prevent recuring forever if there's a `T := T` binding
             if replacement.type_variable_id() == Some(id) {
                 replacement.clone()
             } else {
@@ -2223,7 +2231,7 @@
                 Type::Tuple(fields)
             }
             Type::Forall(typevars, typ) => {
                 // Trying to substitute_helper a variable de, substitute_bound_typevarsfined within a nested Forall
                 // is usually impossible and indicative of an error in the type checker somewhere.
                 for var in typevars {
                     assert!(!type_bindings.contains_key(&var.id()));
@@ -2389,7 +2397,7 @@
         }
     }
 
     /// Follow bindings if this is a type variable or generic to the first non-typevariable
     /// type. Unlike `follow_bindings`, this won't recursively follow any bindings on any
     /// fields or arguments of this type.
     pub fn follow_bindings_shallow(&self) -> Cow<Type> {
@@ -2410,7 +2418,7 @@
 
     /// Replace any `Type::NamedGeneric` in this type with a `Type::TypeVariable`
     /// using to the same inner `TypeVariable`. This is used during monomorphization
     /// to bind to named generics since they are unbindable during type checking.
     pub fn replace_named_generics_with_type_variables(&mut self) {
         match self {
             Type::FieldElement
@@ -2871,7 +2879,7 @@
                 len.hash(state);
                 env.hash(state);
             }
             Type::Tuple(elems) => elems.hash(state),
             Type::Struct(def, args) => {
                 def.hash(state);
                 args.hash(state);

compiler/noirc_frontend/src/tests.rs

@@ -2002,7 +2002,7 @@
 }
 
 // TODO(https://github.com/noir-lang/noir/issues/6238):
 // The EvaluatedGlobalIsntU32 warning is a stopgap
 // (originally from https://github.com/noir-lang/noir/issues/6125)
 #[test]
 fn numeric_generic_field_larger_than_u32() {
@@ -3752,6 +3752,35 @@
     assert_no_errors(src);
 }
 
+#[test]
+fn errors_with_better_message_when_trying_to_invoke_struct_field_that_is_a_function() {
+    let src = r#"
+        pub struct Foo {
+            wrapped: fn(Field) -> bool,
+        }
+
+        impl Foo {
+            fn call(self) -> bool {
+                self.wrapped(1)
+            }
+        }
+
+        fn main() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::CannotInvokeStructFieldFunctionType {
+        method_name,
+        ..
+    }) = &errors[0].0
+    else {
+        panic!("Expected a 'CannotInvokeStructFieldFunctionType' error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(method_name, "wrapped");
+}
+
 fn test_disallows_attribute_on_impl_method(
     attr: &str,
     check_error: impl FnOnce(&CompilationError),