fix all tests, for real this time

compiler-core/src/type_/expression.rs

···
                 if let Err(error) = unify(left.type_(), right.type_()) {
                     self.problems
                         .error(convert_unify_error(error, right.location()));
+                } else {
+                    // We only want to warn for redundant comparisons if it
+                    // makes sense to compare the two values.
+                    // That is, their types should match!
+                    self.check_for_redundant_comparison(name, &left, &right, location);
                 }
 
                 self.check_for_inefficient_empty_list_check(name, &left, &right, location);
-                self.check_for_redundant_comparison(name, &left, &right, location);
 
                 return TypedExpr::BinOp {
                     location,
···
         let unify_left = unify(input_type.clone(), left.type_());
         let unify_right = unify(input_type.clone(), right.type_());
 
+        if unify_left.is_ok() && unify_right.is_ok() {
+            // We only want to warn for redundant comparisons if it makes sense
+            // to compare the two values. That is, their types should match!
+            self.check_for_redundant_comparison(name, &left, &right, location);
+        }
+
         // There's some common cases in which we can provide nicer error messages:
         // - if we're using a float operator on int values
         // - if we're using an int operator on float values
···
         }
 
         self.check_for_inefficient_empty_list_check(name, &left, &right, location);
-        self.check_for_redundant_comparison(name, &left, &right, location);
 
         TypedExpr::BinOp {
             location,
···
             }
         },
 
+        // If we're building two variants with a different index then we can
+        // tell for sure they're going to be different.
+        (one, other)
+            if one
+                .variant_index()
+                .is_some_and(|one| other.variant_index().is_some_and(|other| one != other)) =>
+        {
+            StaticComparison::CertainlyDifferent
+        }
+
         (
             TypedExpr::RecordAccess {
                 index: index_one,
···
         // TODO: For complex expressions we just give up, maybe in future we
         // could be smarter and perform further comparisons but it sounds like
         // there's no huge value in this.
+        //
         (_, _) => StaticComparison::CantTell,
     }
 }

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__different_records_1_redundant_comparison.snap

···
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\npub type Either {\n  Left(Int)\n  Right\n}\n\npub fn main() -> Bool {\n  Left(1) == Right\n}\n"
+---
+----- SOURCE CODE
+
+pub type Either {
+  Left(Int)
+  Right
+}
+
+pub fn main() -> Bool {
+  Left(1) == Right
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:8:3
+  │
+8 │   Left(1) == Right
+  │   ^^^^^^^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__different_records_3_redundant_comparison.snap

···
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\npub type Either {\n  Left\n  Right(Int)\n}\n\npub fn main() -> Bool {\n  Left == Right(1)\n}\n"
+---
+----- SOURCE CODE
+
+pub type Either {
+  Left
+  Right(Int)
+}
+
+pub fn main() -> Bool {
+  Left == Right(1)
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:8:3
+  │
+8 │   Left == Right(1)
+  │   ^^^^^^^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

compiler-core/src/type_/tests/warnings.rs

···
 "
     );
 }
+
+#[test]
+fn different_records_3_redundant_comparison() {
+    assert_warning!(
+        "
+pub type Either {
+  Left
+  Right(Int)
+}
+
+pub fn main() -> Bool {
+  Left == Right(1)
+}
+"
+    );
+}