fix: check infix expression is valid in program input

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1187,7 +1187,6 @@
             | Type::Forall(_, _)
             | Type::Quoted(_)
             | Type::Slice(_)
-            | Type::InfixExpr(_, _, _)
             | Type::TraitAsType(..) => false,
 
             Type::Alias(alias, generics) => {
@@ -1205,6 +1204,10 @@
                 .get_fields(generics)
                 .into_iter()
                 .all(|(_, field)| field.is_valid_for_program_input()),
+
+            Type::InfixExpr(lhs, _, rhs) => {
+                lhs.is_valid_for_program_input() && rhs.is_valid_for_program_input()
+            }
         }
     }
 
@@ -2053,7 +2056,7 @@
 
     /// Instantiates a type with the given types.
     /// This differs from substitute in that only the quantified type variables
     /// are matched against the type list and are eligible for substitution - similar
     /// to normal instantiation. This function is used when the turbofish operator
     /// is used and generic substitutions are provided manually by users.
     ///
@@ -2231,7 +2234,7 @@
                     arg.substitute_helper(type_bindings, substitute_bound_typevars)
                 });
                 let named = vecmap(&generics.named, |arg| {
                     let typ = arg.typ.substitute_helper(type_bindings, substitute_bound_typevars);
                     NamedType { name: arg.name.clone(), typ }
                 });
                 Type::TraitAsType(*s, name.clone(), TraitGenerics { ordered, named })
@@ -2316,7 +2319,7 @@
             String(size) => String(Box::new(size.follow_bindings())),
             FmtString(size, args) => {
                 let size = Box::new(size.follow_bindings());
                 let args = Box::new(args.follow_bindings());
                 FmtString(size, args)
             }
             Struct(def, args) => {
@@ -2488,7 +2491,7 @@
             },
             Type::MutableReference(typ) => typ.integral_maximum_size(),
             Type::InfixExpr(lhs, _op, rhs) => lhs.infix_kind(rhs).integral_maximum_size(),
             Type::Constant(_, kind) => kind.integral_maximum_size(),
 
             Type::Array(..)
             | Type::Slice(..)

compiler/noirc_frontend/src/tests.rs

@@ -1988,7 +1988,7 @@
         fn main() {
             let _ = foo::<A>();
         }
     "#;
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 2);
     assert!(matches!(
@@ -2005,7 +2005,7 @@
 // The EvaluatedGlobalIsntU32 warning is a stopgap
 // (originally from https://github.com/noir-lang/noir/issues/6126)
 #[test]
 fn numeric_generic_field_arithmetic_larger_than_u32() {
     let src = r#"
         struct Foo<let F: Field> {}
 
@@ -2014,7 +2014,7 @@
                 F
             }
         }
 
         // 2^32 - 1
         global A: Field = 4294967295;
 
@@ -3623,3 +3623,41 @@
     "#;
     assert_no_errors(src);
 }
+
+#[test]
+fn allows_struct_with_generic_infix_type_as_main_input_1() {
+    let src = r#"
+        struct Foo<let N: u32> {
+            x: [u64; N * 2],
+        }
+
+        fn main(_x: Foo<18>) {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn allows_struct_with_generic_infix_type_as_main_input_2() {
+    let src = r#"
+        struct Foo<let N: u32> {
+            x: [u64; N * 2],
+        }
+
+        fn main(_x: Foo<2 * 9>) {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn allows_struct_with_generic_infix_type_as_main_input_3() {
+    let src = r#"
+        struct Foo<let N: u32> {
+            x: [u64; N * 2],
+        }
+
+        global N = 9;
+
+        fn main(_x: Foo<N * 2>) {}
+    "#;
+    assert_no_errors(src);
+}