feat: TypeVariableKind for just Integers

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

@@ -567,6 +567,7 @@ impl<'interner> TypeChecker<'interner> {
             Type::Integer(..)
             | Type::FieldElement
             | Type::TypeVariable(_, TypeVariableKind::IntegerOrField)
+            | Type::TypeVariable(_, TypeVariableKind::Integer)
             | Type::Bool => (),
 
             Type::TypeVariable(_, _) => {
@@ -807,7 +808,7 @@ impl<'interner> TypeChecker<'interner> {
 
             // Matches on TypeVariable must be first to follow any type
             // bindings.
-            (TypeVariable(int, _), other) | (other, TypeVariable(int, _)) => {
+            (TypeVariable(int, int_kind), other) | (other, TypeVariable(int, int_kind)) => {
                 if let TypeBinding::Bound(binding) = &*int.borrow() {
                     return self.comparator_operand_type_rules(other, binding, op, span);
                 }
@@ -825,7 +826,13 @@ impl<'interner> TypeChecker<'interner> {
                 }
 
                 let mut bindings = TypeBindings::new();
-                if other.try_bind_to_polymorphic_int(int, &mut bindings).is_ok()
+                if other
+                    .try_bind_to_polymorphic_int(
+                        int,
+                        &mut bindings,
+                        *int_kind == TypeVariableKind::Integer,
+                    )
+                    .is_ok()
                     || other == &Type::Error
                 {
                     Type::apply_type_bindings(bindings);
@@ -1083,7 +1090,7 @@ impl<'interner> TypeChecker<'interner> {
 
             // Matches on TypeVariable must be first so that we follow any type
             // bindings.
-            (TypeVariable(int, _), other) | (other, TypeVariable(int, _)) => {
+            (TypeVariable(int, int_kind), other) | (other, TypeVariable(int, int_kind)) => {
                 if let TypeBinding::Bound(binding) = &*int.borrow() {
                     return self.infix_operand_type_rules(binding, op, other, span);
                 }
@@ -1116,7 +1123,13 @@ impl<'interner> TypeChecker<'interner> {
                 }
 
                 let mut bindings = TypeBindings::new();
-                if other.try_bind_to_polymorphic_int(int, &mut bindings).is_ok()
+                if other
+                    .try_bind_to_polymorphic_int(
+                        int,
+                        &mut bindings,
+                        *int_kind == TypeVariableKind::Integer,
+                    )
+                    .is_ok()
                     || other == &Type::Error
                 {
                     Type::apply_type_bindings(bindings);

compiler/noirc_frontend/src/hir_def/types.rs

@@ -441,6 +441,10 @@ pub enum TypeVariableKind {
     /// type annotations on each integer literal.
     IntegerOrField,
 
+    /// A generic integer type. This is a more specific kind of TypeVariable
+    /// that can only be bound to Type::Integer, or other polymorphic integers.
+    Integer,
+
     /// A potentially constant array size. This will only bind to itself, Type::NotConstant, or
     /// Type::Constant(n) with a matching size. This defaults to Type::Constant(n) if still unbound
     /// during monomorphization.
@@ -746,6 +750,16 @@ impl std::fmt::Display for Type {
                 Signedness::Unsigned => write!(f, "u{num_bits}"),
             },
             Type::TypeVariable(var, TypeVariableKind::Normal) => write!(f, "{}", var.borrow()),
+            Type::TypeVariable(binding, TypeVariableKind::Integer) => {
+                if let TypeBinding::Unbound(_) = &*binding.borrow() {
+                    // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is
+                    // what they bind to by default anyway. It is less confusing than displaying it
+                    // as a generic.
+                    write!(f, "u64")
+                } else {
+                    write!(f, "{}", binding.borrow())
+                }
+            }
             Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
                 if let TypeBinding::Unbound(_) = &*binding.borrow() {
                     // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is
@@ -910,6 +924,7 @@ impl Type {
                             Ok(())
                         }
                         TypeVariableKind::IntegerOrField => Err(UnificationError),
+                        TypeVariableKind::Integer => Err(UnificationError),
                     },
                 }
             }
@@ -924,6 +939,7 @@ impl Type {
         &self,
         var: &TypeVariable,
         bindings: &mut TypeBindings,
+        only_integer: bool,
     ) -> Result<(), UnificationError> {
         let target_id = match &*var.borrow() {
             TypeBinding::Bound(_) => unreachable!(),
@@ -940,7 +956,30 @@ impl Type {
             Type::TypeVariable(self_var, TypeVariableKind::IntegerOrField) => {
                 let borrow = self_var.borrow();
                 match &*borrow {
-                    TypeBinding::Bound(typ) => typ.try_bind_to_polymorphic_int(var, bindings),
+                    TypeBinding::Bound(typ) => {
+                        typ.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                    }
+                    // Avoid infinitely recursive bindings
+                    TypeBinding::Unbound(id) if *id == target_id => Ok(()),
+                    TypeBinding::Unbound(new_target_id) => {
+                        if only_integer {
+                            // Integer is more specific than IntegerOrField so we bind the type
+                            // variable to Integer instead.
+                            let clone = Type::TypeVariable(var.clone(), TypeVariableKind::Integer);
+                            bindings.insert(*new_target_id, (self_var.clone(), clone));
+                        } else {
+                            bindings.insert(target_id, (var.clone(), this.clone()));
+                        }
+                        Ok(())
+                    }
+                }
+            }
+            Type::TypeVariable(self_var, TypeVariableKind::Integer) => {
+                let borrow = self_var.borrow();
+                match &*borrow {
+                    TypeBinding::Bound(typ) => {
+                        typ.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                    }
                     // Avoid infinitely recursive bindings
                     TypeBinding::Unbound(id) if *id == target_id => Ok(()),
                     TypeBinding::Unbound(_) => {
@@ -949,18 +988,26 @@ impl Type {
                     }
                 }
             }
-            Type::TypeVariable(binding, TypeVariableKind::Normal) => {
-                let borrow = binding.borrow();
+            Type::TypeVariable(self_var, TypeVariableKind::Normal) => {
+                let borrow = self_var.borrow();
                 match &*borrow {
-                    TypeBinding::Bound(typ) => typ.try_bind_to_polymorphic_int(var, bindings),
+                    TypeBinding::Bound(typ) => {
+                        typ.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                    }
                     // Avoid infinitely recursive bindings
                     TypeBinding::Unbound(id) if *id == target_id => Ok(()),
                     TypeBinding::Unbound(new_target_id) => {
-                        // IntegerOrField is more specific than TypeVariable so we bind the type
-                        // variable to IntegerOrField instead.
-                        let clone =
-                            Type::TypeVariable(var.clone(), TypeVariableKind::IntegerOrField);
-                        bindings.insert(*new_target_id, (binding.clone(), clone));
+                        let clone_kind = if only_integer {
+                            // Integer is more specific than TypeVariable so we bind the type
+                            // variable to Integer instead.
+                            TypeVariableKind::Integer
+                        } else {
+                            // IntegerOrField is more specific than TypeVariable so we bind the type
+                            // variable to IntegerOrField instead.
+                            TypeVariableKind::IntegerOrField
+                        };
+                        let clone = Type::TypeVariable(var.clone(), clone_kind);
+                        bindings.insert(*new_target_id, (self_var.clone(), clone));
                         Ok(())
                     }
                 }
@@ -1050,7 +1097,16 @@ impl Type {
             (TypeVariable(var, Kind::IntegerOrField), other)
             | (other, TypeVariable(var, Kind::IntegerOrField)) => {
                 other.try_unify_to_type_variable(var, bindings, |bindings| {
-                    other.try_bind_to_polymorphic_int(var, bindings)
+                    let only_integer = false;
+                    other.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                })
+            }
+
+            (TypeVariable(var, Kind::Integer), other)
+            | (other, TypeVariable(var, Kind::Integer)) => {
+                other.try_unify_to_type_variable(var, bindings, |bindings| {
+                    let only_integer = true;
+                    other.try_bind_to_polymorphic_int(var, bindings, only_integer)
                 })
             }
 
@@ -1599,6 +1655,7 @@ impl TypeVariableKind {
     pub(crate) fn default_type(&self) -> Type {
         match self {
             TypeVariableKind::IntegerOrField | TypeVariableKind::Normal => Type::default_int_type(),
+            TypeVariableKind::Integer => Type::default_range_loop_type(),
             TypeVariableKind::Constant(length) => Type::Constant(*length),
         }
     }
@@ -1625,6 +1682,10 @@ impl From<&Type> for PrintableType {
                 Signedness::Unsigned => PrintableType::UnsignedInteger { width: *bit_width },
                 Signedness::Signed => PrintableType::SignedInteger { width: *bit_width },
             },
+            Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
+                TypeBinding::Bound(typ) => typ.into(),
+                TypeBinding::Unbound(_) => Type::default_range_loop_type().into(),
+            },
             Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
                 match &*binding.borrow() {
                     TypeBinding::Bound(typ) => typ.into(),
@@ -1683,6 +1744,9 @@ impl std::fmt::Debug for Type {
             Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
                 write!(f, "IntOrField{:?}", binding)
             }
+            Type::TypeVariable(binding, TypeVariableKind::Integer) => {
+                write!(f, "Int{:?}", binding)
+            }
             Type::TypeVariable(binding, TypeVariableKind::Constant(n)) => {
                 write!(f, "{}{:?}", n, binding)
             }

compiler/noirc_frontend/src/monomorphization/mod.rs

@@ -793,12 +793,14 @@ impl<'interner> Monomorphizer<'interner> {
                 // Default any remaining unbound type variables.
                 // This should only happen if the variable in question is unused
                 // and within a larger generic type.
-                let default =
-                    if self.is_range_loop && matches!(kind, TypeVariableKind::IntegerOrField) {
-                        Type::default_range_loop_type()
-                    } else {
-                        kind.default_type()
-                    };
+                let default = if self.is_range_loop
+                    && (matches!(kind, TypeVariableKind::IntegerOrField)
+                        || matches!(kind, TypeVariableKind::Integer))
+                {
+                    Type::default_range_loop_type()
+                } else {
+                    kind.default_type()
+                };
 
                 let monomorphized_default = self.convert_type(&default);
                 binding.bind(default);

compiler/noirc_frontend/src/node_interner.rs

@@ -1667,6 +1667,7 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::Array(_, _) => Some(Array),
         Type::Integer(_, _) => Some(FieldOrInt),
         Type::TypeVariable(_, TypeVariableKind::IntegerOrField) => Some(FieldOrInt),
+        Type::TypeVariable(_, TypeVariableKind::Integer) => Some(FieldOrInt),
         Type::Bool => Some(Bool),
         Type::String(_) => Some(String),
         Type::FmtString(_, _) => Some(FmtString),

test_programs/compile_success_empty/infer_int_loop_bounds/Nargo.toml

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

test_programs/compile_success_empty/infer_int_loop_bounds/src/main.nr

@@ -0,0 +1,18 @@
+// issue #4290
+fn loop_from<N, K>(_arr: [Field; N], _another: [Field; K]) -> u32 {
+    let mut acc = 0;
+    // N and K are type Field but the iterator is u32
+    for i in N..K {
+        acc += i;
+    }
+    acc
+}
+
+fn main() {
+    let _ = loop_from([0; 10], [0; 20]);
+}
+
+#[test]
+fn test_main() {
+    main();
+}

test_programs/compile_success_empty/int_or_field_casting_loop/Nargo.toml

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

test_programs/compile_success_empty/int_or_field_casting_loop/src/main.nr

@@ -0,0 +1,15 @@
+// issue #3639
+fn main() {
+    for i in 0..8 {
+        for j in 0..8 {
+            if  (i as u64 + j as u64 < 8) {
+                // pass
+            }
+        }
+    }
+}
+
+#[test]
+fn test_main() {
+    main();
+}

tooling/noirc_abi/src/lib.rs

@@ -144,12 +144,11 @@ impl AbiType {
 
                 Self::Integer { sign, width: *bit_width }
             }
-            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
-                match &*binding.borrow() {
-                    TypeBinding::Bound(typ) => Self::from_type(context, typ),
-                    TypeBinding::Unbound(_) => Self::from_type(context, &Type::default_int_type()),
-                }
-            }
+            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField)
+            | Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
+                TypeBinding::Bound(typ) => Self::from_type(context, typ),
+                TypeBinding::Unbound(_) => Self::from_type(context, &Type::default_int_type()),
+            },
             Type::Bool => Self::Boolean,
             Type::String(size) => {
                 let size = size