fix: disallow generics on entry points

compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs

@@ -926,7 +926,7 @@
     //   if it's an inline module, or the first char of a the file if it's an external module.
     // - `location` will always point to the token "foo" in `mod foo` regardless of whether
     //   it's inline or external.
     // Eventually the location put in `ModuleData` is used for codelenses about `contract`s,
     // so we keep using `location` so that it continues to work as usual.
     let location = Location::new(mod_name.span(), mod_location.file);
     let new_module = ModuleData::new(
@@ -1030,6 +1030,15 @@
         interner.register_function(func_id, &function.def);
     }
 
+    if is_entry_point_function {
+        if let Some(generic) = function.def.generics.first() {
+            let name = name.to_string();
+            let location = generic.location();
+            let error = DefCollectorErrorKind::EntryPointWithGenerics { name, location };
+            errors.push(error.into());
+        }
+    }
+
     if !is_test
         && !is_fuzzing_harness
         && !is_entry_point_function

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

@@ -79,6 +79,8 @@ pub enum DefCollectorErrorKind {
     TestOnlyFailWithWithoutParameters { location: Location },
     #[error("The `#[fuzz]` attribute may only be used on functions with parameters")]
     FuzzingHarnessWithoutParameters { location: Location },
+    #[error("`{name}` entry-point function is not allowed to have generic parameters")]
+    EntryPointWithGenerics { name: String, location: Location },
 }
 
 impl DefCollectorErrorKind {
@@ -112,7 +114,8 @@ impl DefCollectorErrorKind {
             | DefCollectorErrorKind::TraitMissingMethod { trait_impl_location: location, .. }
             | DefCollectorErrorKind::ForeignImpl { location, .. }
             | DefCollectorErrorKind::TestOnlyFailWithWithoutParameters { location }
-            | DefCollectorErrorKind::FuzzingHarnessWithoutParameters { location } => *location,
+            | DefCollectorErrorKind::FuzzingHarnessWithoutParameters { location }
+            | DefCollectorErrorKind::EntryPointWithGenerics { location, .. } => *location,
             DefCollectorErrorKind::NotATrait { not_a_trait_name: path }
             | DefCollectorErrorKind::TraitNotFound { trait_path: path } => path.location,
             DefCollectorErrorKind::UnsupportedNumericGenericType(
@@ -297,6 +300,11 @@ impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
                 String::new(),
                 *location,
             ),
+            DefCollectorErrorKind::EntryPointWithGenerics { name, location } => Diagnostic::simple_error(
+                format!("`{name}` entry-point function is not allowed to have generic parameters"),
+                String::new(),
+                *location,
+            ),
         }
     }
 }

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1268,16 +1268,18 @@
         match self {
             // Type::Error is allowed as usual since it indicates an error was already issued and
             // we don't need to issue further errors about this likely unresolved type
+            // TypeVariable and Generic are allowed here too as they can only result from
+            // generics being declared on the function itself, but we produce a different error in that case.
             Type::FieldElement
             | Type::Integer(_, _)
             | Type::Bool
             | Type::Unit
             | Type::Constant(_, _)
+            | Type::TypeVariable(_)
+            | Type::NamedGeneric(_)
             | Type::Error => true,
 
             Type::FmtString(_, _)
-            | Type::TypeVariable(_)
-            | Type::NamedGeneric(_)
             | Type::Function(_, _, _, _)
             | Type::Reference(..)
             | Type::Forall(_, _)
@@ -2397,7 +2399,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 {
@@ -2483,7 +2485,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()));
@@ -2650,7 +2652,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> {
@@ -2675,7 +2677,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
@@ -3221,7 +3223,7 @@
                 len.hash(state);
                 env.hash(state);
             }
             Type::Tuple(elems) => elems.hash(state),
             Type::DataType(def, args) => {
                 def.hash(state);
                 args.hash(state);

test_programs/compile_failure/main_with_generics/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "main_with_generics"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.33.0"
+
+[dependencies]

test_programs/compile_failure/main_with_generics/src/main.nr

@@ -0,0 +1,3 @@
+fn main<let F: u32>(x: [Field; F]) {
+    assert(x[0] != x[1]);
+}

test_programs/compile_failure/main_with_generics/stderr.txt

@@ -0,0 +1,8 @@
+error: `main` entry-point function is not allowed to have generic parameters
+  ┌─ src/main.nr:1:13
+  │
+1 │ fn main<let F: u32>(x: [Field; F]) {
+  │             ------
+  │
+
+Aborting due to 1 previous error