chore: early check type equality in try_unify

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1742,6 +1742,13 @@
     ) -> Result<(), UnificationError> {
         use Type::*;
 
+        // If the two types are exactly the same then they trivially unify.
+        // This check avoids potentially unifying very complex types (usually infix
+        // expressions) when they are the same.
+        if self == other {
+            return Ok(());
+        }
+
         let lhs = self.follow_bindings_shallow();
         let rhs = other.follow_bindings_shallow();
 
@@ -2312,7 +2319,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 {
@@ -2398,7 +2405,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()));
@@ -2564,7 +2571,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> {
@@ -2585,7 +2592,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
@@ -3055,7 +3062,7 @@
                 len.hash(state);
                 env.hash(state);
             }
             Type::Tuple(elems) => elems.hash(state),
             Type::DataType(def, args) => {
                 def.hash(state);
                 args.hash(state);

compiler/noirc_frontend/src/hir_def/types/arithmetic.rs

@@ -63,12 +63,15 @@
                 let dummy_span = Span::default();
                 // evaluate_to_field_element also calls canonicalize so if we just called
                 // `self.evaluate_to_field_element(..)` we'd get infinite recursion.
-                if let (Ok(lhs_value), Ok(rhs_value)) = (
-                    lhs.evaluate_to_field_element_helper(&kind, dummy_span, run_simplifications),
-                    rhs.evaluate_to_field_element_helper(&kind, dummy_span, run_simplifications),
-                ) {
-                    if let Ok(result) = op.function(lhs_value, rhs_value, &kind, dummy_span) {
-                        return Type::Constant(result, kind);
+                if let Ok(lhs_value) =
+                    lhs.evaluate_to_field_element_helper(&kind, dummy_span, run_simplifications)
+                {
+                    if let Ok(rhs_value) =
+                        rhs.evaluate_to_field_element_helper(&kind, dummy_span, run_simplifications)
+                    {
+                        if let Ok(result) = op.function(lhs_value, rhs_value, &kind, dummy_span) {
+                            return Type::Constant(result, kind);
+                        }
                     }
                 }
 
@@ -499,7 +502,7 @@
     // Generate (arbitrary_unsigned_type, generator for that type)
     fn arbitrary_unsigned_type_with_generator() -> BoxedStrategy<(Type, BoxedStrategy<FieldElement>)>
     {
         prop_oneof![
             strategy::Just((Type::FieldElement, arbitrary_field_element().boxed())),
             any::<IntegerBitSize>().prop_map(|bit_size| {
                 let typ = Type::Integer(Signedness::Unsigned, bit_size);
@@ -536,7 +539,7 @@
         arbitrary_value: BoxedStrategy<FieldElement>,
         num_variables: usize,
     ) -> impl Strategy<Value = Type> {
         let leaf = prop_oneof![
             arbitrary_variable(typ.clone(), num_variables),
             arbitrary_value
                 .prop_map(move |value| Type::Constant(value, Kind::numeric(typ.clone()))),