fix: Nested array equality

compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs

@@ -566,22 +566,12 @@ impl<'a> FunctionContext<'a> {
         mut rhs: ValueId,
         location: Location,
     ) -> Values {
-        let result_type = self.builder.type_of_value(lhs);
-        let mut result = match operator {
-            BinaryOpKind::Equal | BinaryOpKind::NotEqual
-                if matches!(result_type, Type::Array(..)) =>
-            {
-                return self.insert_array_equality(lhs, operator, rhs, location)
-            }
-            _ => {
-                let op = convert_operator(operator);
-                if operator_requires_swapped_operands(operator) {
-                    std::mem::swap(&mut lhs, &mut rhs);
-                }
+        let op = convert_operator(operator);
+        if operator_requires_swapped_operands(operator) {
+            std::mem::swap(&mut lhs, &mut rhs);
+        }
 
-                self.builder.set_location(location).insert_binary(lhs, op, rhs)
-            }
-        };
+        let mut result = self.builder.set_location(location).insert_binary(lhs, op, rhs);
 
         // Check for integer overflow
         if matches!(

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

@@ -890,26 +890,6 @@ impl<'interner> TypeChecker<'interner> {
             // <= and friends are technically valid for booleans, just not very useful
             (Bool, Bool) => Ok((Bool, false)),
 
-            // Special-case == and != for arrays
-            (Array(x_size, x_type), Array(y_size, y_type))
-                if matches!(op.kind, BinaryOpKind::Equal | BinaryOpKind::NotEqual) =>
-            {
-                self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource {
-                    expected: lhs_type.clone(),
-                    actual: rhs_type.clone(),
-                    source: Source::ArrayLen,
-                    span: op.location.span,
-                });
-
-                let (_, use_impl) = self.comparator_operand_type_rules(x_type, y_type, op, span)?;
-
-                // If the size is not constant, we must fall back to a user-provided impl for
-                // equality on slices.
-                let size = x_size.follow_bindings();
-                let use_impl = use_impl || size.evaluate_to_u64().is_none();
-                Ok((Bool, use_impl))
-            }
-
             (String(x_size), String(y_size)) => {
                 self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource {
                     expected: *x_size.clone(),

test_programs/execution_success/regression_4383/Nargo.toml

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

test_programs/execution_success/regression_4383/src/main.nr

@@ -0,0 +1,3 @@
+fn main() {
+    assert([[1]] == [[1]]);
+}