fix: type variables by default should have Any kind

compiler/noirc_frontend/src/hir_def/types.rs

@@ -881,7 +881,7 @@
     }
 
     pub fn type_variable(id: TypeVariableId) -> Type {
-        let var = TypeVariable::unbound(id, Kind::Normal);
+        let var = TypeVariable::unbound(id, Kind::Any);
         Type::TypeVariable(var)
     }
 
@@ -1978,7 +1978,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 {
@@ -2058,7 +2058,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()));
@@ -2225,7 +2225,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
@@ -2594,7 +2594,7 @@
                 len.hash(state);
                 env.hash(state);
             }
             Type::Tuple(elems) => elems.hash(state),
             Type::Struct(def, args) => {
                 def.hash(state);
                 args.hash(state);
@@ -2695,7 +2695,7 @@
             // Special case: we consider unbound named generics and type variables to be equal to each
             // other if their type variable ids match. This is important for some corner cases in
             // monomorphization where we call `replace_named_generics_with_type_variables` but
             // still want them to be equal for canonicalization checks in arithmetic generics.
             // Without this we'd fail the `serialize` test.
             (
                 NamedGeneric(lhs_var, _) | TypeVariable(lhs_var),

compiler/noirc_frontend/src/tests/turbofish.rs

@@ -196,3 +196,21 @@ fn turbofish_in_struct_pattern_generic_count_mismatch() {
     assert_eq!(*expected, 1);
     assert_eq!(*found, 2);
 }
+
+#[test]
+fn numeric_turbofish() {
+    let src = r#"
+    struct Reader<let N: u32> {
+    }
+
+    impl<let N: u32> Reader<N> {
+        fn read<let C: u32>(_self: Self) {}
+    }
+
+    fn main() {
+        let reader: Reader<1234> = Reader {};
+        let _ = reader.read::<1234>();
+    }
+    "#;
+    assert_no_errors(src);
+}