Fix false-positive redundant comparisons warning

Author: abs0luty

CHANGELOG.md

@@ -34,6 +34,24 @@
   than stopping at the syntax error.
   ([mxtthias](https://github.com/mxtthias))
 
+- Fixed a false-positive warning where the compiler claimed all comparisons of 
+  constructors were redundant and equal to `True`:
+  ```gleam
+  type Comparison {
+    Wibble
+    Wobble(String)
+  }
+
+  pub fn main() {
+    echo Wibble == Wibble // True
+    echo Wobble == Wobble // False
+  }
+  ```
+  In reality, nullary constructors are values (`Wibble == Wibble`), while 
+  constructors with arguments are functions: `Wobble != Wobble`. The old warning 
+  incorrectly suggested both were true.
+  ([Adi Salimgereyev](https://github.com/abs0luty))
+
 ### Build tool
 
 - The help text displayed by `gleam dev --help`, `gleam test --help`, and

compiler-core/src/type_/expression.rs

@@ -5202,11 +5202,25 @@ fn static_compare(one: &TypedExpr, other: &TypedExpr) -> StaticComparison {
             | (
                 ValueConstructorVariant::LocalConstant { .. },
                 ValueConstructorVariant::LocalConstant { .. },
-            )
-            | (ValueConstructorVariant::Record { .. }, ValueConstructorVariant::Record { .. })
-                if one == other =>
-            {
-                StaticComparison::CertainlyEqual
+            ) if one == other => StaticComparison::CertainlyEqual,
+
+            // Zero-arity record constructors with the same name are certainly equal
+            (
+                ValueConstructorVariant::Record { arity: 0, .. },
+                ValueConstructorVariant::Record { arity: 0, .. },
+            ) if one == other => StaticComparison::CertainlyEqual,
+
+            // Non-zero arity record constructors are functions, and comparing
+            // functions always returns False even if they have the same name
+            (
+                ValueConstructorVariant::Record {
+                    arity: arity_one, ..
+                },
+                ValueConstructorVariant::Record {
+                    arity: arity_two, ..
+                },
+            ) if one == other && *arity_one > 0 && *arity_two > 0 => {
+                StaticComparison::CertainlyDifferent
             }
 
             (

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

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\ntype Comparison {\n  Wobble(String)\n}\n\npub fn main() {\n  Wobble(\"a\") == Wobble(\"a\")\n}\n"
+---
+----- SOURCE CODE
+
+type Comparison {
+  Wobble(String)
+}
+
+pub fn main() {
+  Wobble("a") == Wobble("a")
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:7:3
+  │
+7 │   Wobble("a") == Wobble("a")
+  │   ^^^^^^^^^^^^^^^^^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.

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

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\ntype Comparison {\n  Wobble(String)\n}\n\npub fn main() {\n  Wobble == Wobble\n}\n"
+---
+----- SOURCE CODE
+
+type Comparison {
+  Wobble(String)
+}
+
+pub fn main() {
+  Wobble == Wobble
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:7:3
+  │
+7 │   Wobble == Wobble
+  │   ^^^^^^^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

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

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\ntype Comparison {\n  Wobble(String)\n}\n\npub fn main() {\n  Wobble != Wobble\n}\n"
+---
+----- SOURCE CODE
+
+type Comparison {
+  Wobble(String)
+}
+
+pub fn main() {
+  Wobble != Wobble
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:7:3
+  │
+7 │   Wobble != Wobble
+  │   ^^^^^^^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.

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

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\ntype Comparison {\n  Wobble(String, Int)\n}\n\npub fn main() {\n  Wobble == Wobble\n}\n"
+---
+----- SOURCE CODE
+
+type Comparison {
+  Wobble(String, Int)
+}
+
+pub fn main() {
+  Wobble == Wobble
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:7:3
+  │
+7 │   Wobble == Wobble
+  │   ^^^^^^^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

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

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\ntype Comparison {\n  Wibble\n}\n\npub fn main() {\n  Wibble == Wibble\n}\n"
+---
+----- SOURCE CODE
+
+type Comparison {
+  Wibble
+}
+
+pub fn main() {
+  Wibble == Wibble
+}
+
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:7:3
+  │
+7 │   Wibble == Wibble
+  │   ^^^^^^^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.

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

@@ -4612,3 +4612,78 @@ pub type Wobble
 "#,
     );
 }
+
+#[test]
+fn redundant_comparison_zero_arity_constructor() {
+    assert_warning!(
+        "
+type Comparison {
+  Wibble
+}
+
+pub fn main() {
+  Wibble == Wibble
+}
+"
+    );
+}
+
+#[test]
+fn redundant_comparison_constructor_function() {
+    assert_warning!(
+        "
+type Comparison {
+  Wobble(String)
+}
+
+pub fn main() {
+  Wobble == Wobble
+}
+"
+    );
+}
+
+#[test]
+fn redundant_comparison_constructor() {
+    assert_warning!(
+        "
+type Comparison {
+  Wobble(String)
+}
+
+pub fn main() {
+  Wobble(\"a\") == Wobble(\"a\")
+}
+"
+    );
+}
+
+#[test]
+fn redundant_comparison_constructor_function_not_eq() {
+    assert_warning!(
+        "
+type Comparison {
+  Wobble(String)
+}
+
+pub fn main() {
+  Wobble != Wobble
+}
+"
+    );
+}
+
+#[test]
+fn redundant_comparison_multi_param_constructor_function() {
+    assert_warning!(
+        "
+type Comparison {
+  Wobble(String, Int)
+}
+
+pub fn main() {
+  Wobble == Wobble
+}
+"
+    );
+}