emit a single warning for chains of double negations

Author: giacomocavalieri

CHANGELOG.md

@@ -64,6 +64,11 @@
   errors.
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- The compiler now emits a single warning for multiple negations in a row, while
+  previously it would emit multiple comments highlighting increasingly longer
+  spans.
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 ### Build tool
 
 - New projects are generated using OTP28 on GitHub Actions.

compiler-core/src/type_/expression.rs

@@ -877,25 +877,65 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
     }
 
     fn infer_negate_bool(&mut self, location: SrcSpan, value: UntypedExpr) -> TypedExpr {
-        let value = self.infer(value);
+        self.infer_multiple_negate_bool(location, 1, location, value)
+    }
 
+    fn infer_multiple_negate_bool(
+        &mut self,
+        starting_location: SrcSpan,
+        negations: usize,
+        location: SrcSpan,
+        value: UntypedExpr,
+    ) -> TypedExpr {
+        // If we're typing a double negation we just keep going increasing the
+        // number of consecutive negations, inferring the wrapped value.
+        if let UntypedExpr::NegateBool {
+            location: inner_location,
+            value,
+        } = value
+        {
+            return TypedExpr::NegateBool {
+                location,
+                value: Box::new(self.infer_multiple_negate_bool(
+                    starting_location,
+                    negations + 1,
+                    inner_location,
+                    *value,
+                )),
+            };
+        }
+
+        // We know the last value can't be a bool negation if we're here, so
+        // we're ready to produce a typed value!
+        let value = self.infer(value);
         if let Err(error) = unify(bool(), value.type_()) {
             self.problems
-                .error(convert_unify_error(error, value.location()))
+                .error(convert_unify_error(error, value.location()));
         }
 
-        if let TypedExpr::NegateBool {
-            location: inner_location,
-            ..
-        } = value
-        {
+        // If there's more than a single negation we can raise a warning
+        // highlighting the unneded ones. How many negations are highlighted
+        // depends if they're an even or odd number:
+        //
+        // ```gleam
+        // !!True   // all negations are superfluous.
+        // !!!True  // we can remove all but one negation.
+        // ```
+        if negations > 1 {
+            let location = if negations % 2 == 0 {
+                SrcSpan {
+                    start: starting_location.start,
+                    end: location.start + 1,
+                }
+            } else {
+                SrcSpan {
+                    start: starting_location.start,
+                    end: location.start,
+                }
+            };
+
             self.problems
-                .warning(Warning::UnnecessaryDoubleBoolNegation {
-                    location: SrcSpan {
-                        start: location.start,
-                        end: inner_location.start + 1,
-                    },
-                });
+                .warning(Warning::UnnecessaryDoubleBoolNegation { location });
         }
 
         TypedExpr::NegateBool {
@@ -905,41 +945,82 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
     }
 
     fn infer_negate_int(&mut self, location: SrcSpan, value: UntypedExpr) -> TypedExpr {
-        let value = self.infer(value);
+        self.infer_multiple_negate_int(location, 1, location, value)
+    }
 
+    fn infer_multiple_negate_int(
+        &mut self,
+        starting_location: SrcSpan,
+        mut negations: usize,
+        location: SrcSpan,
+        value: UntypedExpr,
+    ) -> TypedExpr {
+        // If we're typing a double negation we just keep going increasing the
+        // number of consecutive negations, inferring the wrapped value.
+        if let UntypedExpr::NegateInt {
+            location: inner_location,
+            value,
+        } = value
+        {
+            return TypedExpr::NegateInt {
+                location,
+                value: Box::new(self.infer_multiple_negate_int(
+                    starting_location,
+                    negations + 1,
+                    inner_location,
+                    *value,
+                )),
+            };
+        }
+
+        // We know the last value can't be an int negation, so we're ready to
+        // produce a typed value!
+        let value = self.infer(value);
         if let Err(error) = unify(int(), value.type_()) {
             self.problems
                 .error(convert_unify_error(error, value.location()));
         }
 
+        // This is used to emit a warning in case there's multiple negations.
+        let mut end = location.start;
+
+        // There's one special case where the final integer being typed might be
+        // negated as well, in that case we need to update the number of
+        // consecutive negations.
         if let TypedExpr::Int {
             value: ref v,
-            location: ref inner_location,
+            ref location,
             ..
         } = value
             && v.starts_with('-')
         {
-            self.problems
-                .warning(Warning::UnnecessaryDoubleIntNegation {
-                    location: SrcSpan {
-                        start: location.start,
-                        end: inner_location.start + 1,
-                    },
-                });
+            negations += 1;
+            end = location.start;
         }
 
-        if let TypedExpr::NegateInt {
-            location: inner_location,
-            ..
-        } = value
-        {
+        // If there's more than a single negation we can raise a warning
+        // highlighting the unneded ones. How many negations are highlighted
+        // depends if they're an even or odd number:
+        //
+        // ```gleam
+        // --1   // all negations are superfluous.
+        // ---1  // we can remove all but one negation.
+        // ```
+        if negations > 1 {
+            let location = if negations % 2 == 0 {
+                SrcSpan {
+                    start: starting_location.start,
+                    end: end + 1,
+                }
+            } else {
+                SrcSpan {
+                    start: starting_location.start,
+                    end,
+                }
+            };
+
             self.problems
-                .warning(Warning::UnnecessaryDoubleIntNegation {
-                    location: SrcSpan {
-                        start: location.start,
-                        end: inner_location.start + 1,
-                    },
-                });
+                .warning(Warning::UnnecessaryDoubleIntNegation { location });
         }
 
         TypedExpr::NegateInt {

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

@@ -0,0 +1,13 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { let _ = !!!!True }"
+---
+----- SOURCE CODE
+pub fn main() { let _ = !!!!True }
+
+----- WARNING
+warning: Unnecessary double negation (!!) on bool
+  ┌─ /src/warning/wrn.gleam:1:25
+  │
+1 │ pub fn main() { let _ = !!!!True }
+  │                         ^^^^ You can safely remove this.

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

@@ -0,0 +1,13 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { let _ = ----7 }"
+---
+----- SOURCE CODE
+pub fn main() { let _ = ----7 }
+
+----- WARNING
+warning: Unnecessary double negation (--) on integer
+  ┌─ /src/warning/wrn.gleam:1:25
+  │
+1 │ pub fn main() { let _ = ----7 }
+  │                         ^^^^ You can safely remove this.

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

@@ -0,0 +1,13 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { let _ = !!!!!False }"
+---
+----- SOURCE CODE
+pub fn main() { let _ = !!!!!False }
+
+----- WARNING
+warning: Unnecessary double negation (!!) on bool
+  ┌─ /src/warning/wrn.gleam:1:25
+  │
+1 │ pub fn main() { let _ = !!!!!False }
+  │                         ^^^^ You can safely remove this.

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

@@ -0,0 +1,13 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "pub fn main() { let _ = -----7 }"
+---
+----- SOURCE CODE
+pub fn main() { let _ = -----7 }
+
+----- WARNING
+warning: Unnecessary double negation (--) on integer
+  ┌─ /src/warning/wrn.gleam:1:25
+  │
+1 │ pub fn main() { let _ = -----7 }
+  │                         ^^^^ You can safely remove this.

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

@@ -464,6 +464,28 @@ fn double_unary_integer_literal() {
     assert_warning!("pub fn main() { let _ = --7 }");
 }
 
+#[test]
+fn even_number_of_multiple_integer_negations_raise_a_single_warning() {
+    assert_warning!("pub fn main() { let _ = ----7 }");
+}
+
+#[test]
+fn odd_number_of_multiple_integer_negations_raise_a_single_warning_that_highlights_the_unnecessary_ones()
+ {
+    assert_warning!("pub fn main() { let _ = -----7 }");
+}
+
+#[test]
+fn even_number_of_multiple_bool_negations_raise_a_single_warning() {
+    assert_warning!("pub fn main() { let _ = !!!!True }");
+}
+
+#[test]
+fn odd_number_of_multiple_bool_negations_raise_a_single_warning_that_highlights_the_unnecessary_ones()
+ {
+    assert_warning!("pub fn main() { let _ = !!!!!False }");
+}
+
 // https://github.com/gleam-lang/gleam/issues/2050
 #[test]
 fn double_unary_integer_variable() {