🐛 Use f64 for float comparison check

Author: fruno-bulax

compiler-core/src/ast.rs

@@ -1739,11 +1739,11 @@ fn pattern_and_expression_are_the_same(pattern: &TypedPattern, expression: &Type
         // `"wibble" -> "wibble"`
         (
             TypedPattern::Float {
-                value: pattern_value,
+                float_value: pattern_value,
                 ..
             },
-            TypedExpr::Float { value, .. },
-        ) => pattern_value == value,
+            TypedExpr::Float { float_value, .. },
+        ) => pattern_value == float_value,
         (TypedPattern::Float { .. }, _) => false,
 
         (

compiler-core/src/parse.rs

@@ -4751,3 +4751,17 @@ impl LiteralFloatValue {
 }
 
 impl Eq for LiteralFloatValue {}
+
+impl Ord for LiteralFloatValue {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.0
+            .partial_cmp(&other.0)
+            .expect("Only NaN comparisons should fail")
+    }
+}
+
+impl PartialOrd for LiteralFloatValue {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}

compiler-core/src/type_/expression.rs

@@ -1964,6 +1964,22 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
                 }
             }
 
+            (
+                TypedExpr::Float { float_value: n, .. },
+                op,
+                TypedExpr::Float { float_value: m, .. },
+            ) => match op {
+                BinOp::LtFloat if n < m => ComparisonOutcome::AlwaysSucceeds,
+                BinOp::LtFloat => ComparisonOutcome::AlwaysFails,
+                BinOp::LtEqFloat if n <= m => ComparisonOutcome::AlwaysSucceeds,
+                BinOp::LtEqFloat => ComparisonOutcome::AlwaysFails,
+                BinOp::GtFloat if n > m => ComparisonOutcome::AlwaysSucceeds,
+                BinOp::GtFloat => ComparisonOutcome::AlwaysFails,
+                BinOp::GtEqFloat if n >= m => ComparisonOutcome::AlwaysSucceeds,
+                BinOp::GtEqFloat => ComparisonOutcome::AlwaysFails,
+                _ => return,
+            },
+
             _ => return,
         };
 
@@ -5222,7 +5238,7 @@ fn static_compare(one: &TypedExpr, other: &TypedExpr) -> StaticComparison {
             }
         }
 
-        (TypedExpr::Float { value: n, .. }, TypedExpr::Float { value: m, .. }) => {
+        (TypedExpr::Float { float_value: n, .. }, TypedExpr::Float { float_value: m, .. }) => {
             if n == m {
                 StaticComparison::CertainlyEqual
             } else {

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 == 1.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 == 1.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 == 1.0 }
+  │                 ^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 == 2.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 == 2.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 == 2.0 }
+  │                 ^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 != 1.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 != 1.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 != 1.0 }
+  │                 ^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 != 2.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 != 2.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 != 2.0 }
+  │                 ^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 >. 2.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 >. 2.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 >. 2.0 }
+  │                 ^^^^^^^^^^ This is always `False`
+
+This comparison is redundant since it always fails.

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 <=. 2.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 <=. 2.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 <=. 2.0 }
+  │                 ^^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.

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

@@ -0,0 +1,15 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { 1.0 <. 2.0 }"
+---
+----- SOURCE CODE
+pub fn main() { 1.0 <. 2.0 }
+
+----- WARNING
+warning: Redundant comparison
+  ┌─ /src/warning/wrn.gleam:1:17
+  │
+1 │ pub fn main() { 1.0 <. 2.0 }
+  │                 ^^^^^^^^^^ This is always `True`
+
+This comparison is redundant since it always succeeds.