Optimise comparison with singleton custom types on JavaScript #4903. also fixed some clippy errors

Author: re-masashi

compiler-core/src/analyse.rs

@@ -51,9 +51,10 @@ use vec1::Vec1;
 
 use self::imports::Importer;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub enum Inferred<T> {
     Known(T),
+    #[default]
     Unknown,
 }
 

compiler-core/src/ast.rs

@@ -2473,12 +2473,6 @@ impl<T> BitArraySize<T> {
     }
 }
 
-impl Default for Inferred<()> {
-    fn default() -> Self {
-        Self::Unknown
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum AssignName {
     Variable(EcoString),

compiler-core/src/erlang.rs

@@ -708,7 +708,7 @@ fn string_inner(value: &str) -> Document<'_> {
         .replace_all(value, |caps: &Captures<'_>| {
             let slashes = caps.get(1).map_or("", |m| m.as_str());
 
-            if slashes.len() % 2 == 0 {
+            if slashes.len().is_multiple_of(2) {
                 format!("{slashes}u")
             } else {
                 format!("{slashes}x")

compiler-core/src/javascript/expression.rs

@@ -1536,11 +1536,62 @@ impl<'module, 'a> Generator<'module, 'a> {
             return docvec![left_doc, operator, right_doc];
         }
 
+        // Optimise comparison with singleton custom types on JavaScript (https://gleam-lang/gleam/issues/4903)
+        if let (
+            _,
+            // RHS: singleton record constructor (arity 0)
+            TypedExpr::Var {
+                constructor:
+                    ValueConstructor {
+                        variant: ValueConstructorVariant::Record { arity: 0, name, .. },
+                        ..
+                    },
+                ..
+            },
+        ) = (left, right)
+        {
+            let left_doc = self
+                .not_in_tail_position(Some(Ordering::Strict), |this| this.wrap_expression(left));
+
+            let constructor_name = name.to_doc();
+
+            if should_be_equal {
+                return docvec![left_doc, " instanceof ", constructor_name];
+            } else {
+                return docvec!["!(", left_doc, " instanceof ", constructor_name, ")"];
+            }
+        }
+
+        if let (
+            // LHS: singleton record constructor (arity 0)
+            TypedExpr::Var {
+                constructor:
+                    ValueConstructor {
+                        variant: ValueConstructorVariant::Record { arity: 0, name, .. },
+                        ..
+                    },
+                ..
+            },
+            _,
+        ) = (left, right)
+        {
+            let right_doc = self
+                .not_in_tail_position(Some(Ordering::Strict), |this| this.wrap_expression(right));
+            let constructor_name = name.to_doc();
+
+            if should_be_equal {
+                return docvec![right_doc, " instanceof ", constructor_name];
+            } else {
+                return docvec!["!(", right_doc, " instanceof ", constructor_name, ")"];
+            }
+        }
+
         // Other types must be compared using structural equality
         let left =
             self.not_in_tail_position(Some(Ordering::Strict), |this| this.wrap_expression(left));
         let right =
             self.not_in_tail_position(Some(Ordering::Strict), |this| this.wrap_expression(right));
+
         self.prelude_equal_call(should_be_equal, left, right)
     }
 

compiler-core/src/javascript/tests/singleton_comparison_optimisation.rs

@@ -0,0 +1,120 @@
+use crate::assert_js;
+
+#[test]
+fn singleton_record_equality() {
+    assert_js!(
+        r#"
+pub type Wibble {
+  Wibble
+  Wobble
+}
+
+pub fn is_wibble(w: Wibble) -> Bool {
+  w == Wibble
+}
+"#,
+    );
+}
+
+#[test]
+fn singleton_record_inequality() {
+    assert_js!(
+        r#"
+pub type Wibble {
+  Wibble
+  Wobble
+}
+
+pub fn is_not_wibble(w: Wibble) -> Bool {
+  w != Wibble
+}
+"#,
+    );
+}
+
+#[test]
+fn singleton_record_reverse_order() {
+    assert_js!(
+        r#"
+pub type Wibble {
+  Wibble
+  Wobble
+}
+
+pub fn is_wibble_reverse(w: Wibble) -> Bool {
+  Wibble == w
+}
+"#,
+    );
+}
+
+#[test]
+fn non_singleton_record_equality() {
+    assert_js!(
+        r#"
+pub type Person {
+  Person(name: String, age: Int)
+}
+
+pub fn same_person(p1: Person, p2: Person) -> Bool {
+  p1 == p2
+}
+"#,
+    );
+}
+
+#[test]
+fn multiple_singleton_constructors() {
+    assert_js!(
+        r#"
+pub type Status {
+  Loading
+  Success
+  Error
+}
+
+pub fn is_loading(s: Status) -> Bool {
+  s == Loading
+}
+
+pub fn is_success(s: Status) -> Bool {
+  s == Success
+}
+"#,
+    );
+}
+
+#[test]
+fn mixed_singleton_and_non_singleton() {
+    assert_js!(
+        r#"
+pub type Result {
+  Ok(value: Int)
+  Error
+}
+
+pub fn is_error(r: Result) -> Bool {
+  r == Error
+}
+"#,
+    );
+}
+
+#[test]
+fn singleton_in_case_guard() {
+    assert_js!(
+        r#"
+pub type State {
+  Active
+  Inactive
+}
+
+pub fn process(s: State) -> String {
+  case s {
+    state if state == Active -> "active"
+    _ -> "inactive"
+  }
+}
+"#,
+    );
+}

compiler-core/src/type_.rs

@@ -1375,10 +1375,13 @@ pub struct ValueConstructor {
     pub type_: Arc<Type>,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Default)]
 pub enum Deprecation {
+    #[default]
     NotDeprecated,
-    Deprecated { message: EcoString },
+    Deprecated {
+        message: EcoString,
+    },
 }
 
 impl Deprecation {
@@ -1391,12 +1394,6 @@ impl Deprecation {
     }
 }
 
-impl Default for Deprecation {
-    fn default() -> Self {
-        Self::NotDeprecated
-    }
-}
-
 impl ValueConstructor {
     pub fn local_variable(location: SrcSpan, origin: VariableOrigin, type_: Arc<Type>) -> Self {
         Self {

compiler-core/src/type_/expression.rs

@@ -924,7 +924,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         // !!!True  // we can remove all but one negation.
         // ```
         if negations > 1 {
-            let location = if negations % 2 == 0 {
+            let location = if negations.is_multiple_of(2) {
                 SrcSpan {
                     start: starting_location.start,
                     end: location.start + 1,
@@ -1009,7 +1009,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         // ---1  // we can remove all but one negation.
         // ```
         if negations > 1 {
-            let location = if negations % 2 == 0 {
+            let location = if negations.is_multiple_of(2) {
                 SrcSpan {
                     start: starting_location.start,
                     end: end + 1,