Optimise comparison with singleton custom types on JavaScript #4903

Author: re-masashi

CHANGELOG.md

@@ -29,6 +29,10 @@
 
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- The performance of `==` and `!=` has been improved for single-variant custom types
+  compared using `instanceof` instead of `isEqual(new Variant())`).
+  ([Nafi](https://github.com/re-masashi))
+
 - The lowercase bool pattern error is no longer a syntax error, but instead a
   part of the analysis step. This allows the entire module to be analyzed, rather
   than stopping at the syntax error.

compiler-core/src/javascript/expression.rs

@@ -1536,14 +1536,75 @@ impl<'module, 'a> Generator<'module, 'a> {
             return docvec![left_doc, operator, right_doc];
         }
 
+        // For comparison with singleton custom types, ie, one with no fields.
+        // If you have some code like this
+        // ```gleam
+        //  pub type Wibble {
+        //    Wibble
+        //    Wobble
+        //  }
+
+        //  pub fn is_wibble(w: Wibble) -> Bool {
+        //    w == Wibble
+        //  }
+        // ```
+        // Instead of `isEqual(w, new Wibble())`, generate `w instanceof Wibble`
+        // because the first approach needs to construct a new Wibble, and then call the isEqual function,
+        // which supports any shape of data, and so does a lot of extra logic which isn't necessary.
+
+        if let Some(doc) = self.singleton_variant_equality(left, right, should_be_equal) {
+            return doc;
+        }
+
+        if let Some(doc) = self.singleton_variant_equality(right, left, should_be_equal) {
+            return doc;
+        }
+
         // 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)
     }
 
+    fn singleton_variant_equality(
+        &mut self,
+        left: &'a TypedExpr,
+        right: &'a TypedExpr,
+        should_be_equal: bool,
+    ) -> Option<Document<'a>> {
+        if let TypedExpr::Var {
+            constructor:
+                ValueConstructor {
+                    variant: ValueConstructorVariant::Record { arity: 0, name, .. },
+                    ..
+                },
+            ..
+        } = right
+        {
+            let left_doc = self
+                .not_in_tail_position(Some(Ordering::Strict), |this| this.wrap_expression(left));
+            Some(self.singleton_equal(left_doc, name, should_be_equal))
+        } else {
+            None
+        }
+    }
+
+    fn singleton_equal(
+        &self,
+        value: Document<'a>,
+        tag: &EcoString,
+        should_be_equal: bool,
+    ) -> Document<'a> {
+        if should_be_equal {
+            docvec![value, " instanceof ", tag.to_doc()]
+        } else {
+            docvec!["!(", value, " instanceof ", tag.to_doc(), ")"]
+        }
+    }
+
     fn equal_with_doc_operands(
         &mut self,
         left: Document<'a>,
@@ -1966,16 +2027,26 @@ impl<'module, 'a> Generator<'module, 'a> {
                 docvec![left, " !== ", right]
             }
 
-            ClauseGuard::Equals { left, right, .. } => {
-                let left = self.guard(left);
-                let right = self.guard(right);
-                self.prelude_equal_call(true, left, right)
-            }
+            ClauseGuard::Equals { left, right, .. }
+            | ClauseGuard::NotEquals { left, right, .. } => {
+                let should_be_equal = matches!(guard, ClauseGuard::Equals { .. });
+
+                // Handle singleton equality optimization for guards
+                if let Some(doc) =
+                    self.singleton_variant_guard_equality(left, right, should_be_equal)
+                {
+                    return doc;
+                }
 
-            ClauseGuard::NotEquals { left, right, .. } => {
-                let left = self.guard(left);
-                let right = self.guard(right);
-                self.prelude_equal_call(false, left, right)
+                if let Some(doc) =
+                    self.singleton_variant_guard_equality(right, left, should_be_equal)
+                {
+                    return doc;
+                }
+
+                let left_doc = self.guard(left);
+                let right_doc = self.guard(right);
+                self.prelude_equal_call(should_be_equal, left_doc, right_doc)
             }
 
             ClauseGuard::GtFloat { left, right, .. } | ClauseGuard::GtInt { left, right, .. } => {
@@ -2078,6 +2149,25 @@ impl<'module, 'a> Generator<'module, 'a> {
         }
     }
 
+    fn singleton_variant_guard_equality(
+        &mut self,
+        left: &'a TypedClauseGuard,
+        right: &'a TypedClauseGuard,
+        should_be_equal: bool,
+    ) -> Option<Document<'a>> {
+        if let ClauseGuard::Constant(Constant::Record {
+            record_constructor: Some(constructor),
+            name,
+            ..
+        }) = right
+            && let ValueConstructorVariant::Record { arity: 0, .. } = constructor.variant
+        {
+            let left_doc = self.guard(left);
+            return Some(self.singleton_equal(left_doc, name, should_be_equal));
+        }
+        None
+    }
+
     fn wrapped_guard(&mut self, guard: &'a TypedClauseGuard) -> Document<'a> {
         match guard {
             ClauseGuard::Var { .. }