Optimise comparison with singleton custom types on JavaScript #4903. …

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

@@ -178,6 +178,26 @@ pub(crate) struct Generator<'module, 'ast> {
     pub let_assert_always_panics: bool,
 }
 
+fn ctor_tag(g: &TypedClauseGuard) -> Option<EcoString> {
+    match g {
+        ClauseGuard::Constant(Constant::Record {
+            arguments, name, ..
+        }) if arguments.is_empty() => Some(name.clone()),
+        _ => None,
+    }
+}
+
+fn is_var(g: &TypedClauseGuard) -> bool {
+    matches!(g, ClauseGuard::Var { .. })
+}
+
+fn looks_like_constructor_alias(var: &TypedClauseGuard) -> bool {
+    match var {
+        ClauseGuard::Var { type_, .. } => matches!(&**type_, Type::Fn { .. }), // lambda
+        _ => false,
+    }
+}
+
 impl<'module, 'a> Generator<'module, 'a> {
     #[allow(clippy::too_many_arguments)] // TODO: FIXME
     pub fn new(
@@ -1536,14 +1556,74 @@ 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.
+
+        // RHS: singleton record constructor (arity 0)
+        if let TypedExpr::Var {
+            constructor:
+                ValueConstructor {
+                    variant: ValueConstructorVariant::Record { arity: 0, name, .. },
+                    ..
+                },
+            ..
+        } = right
+        {
+            return self.singleton_equal_helper(left, name, should_be_equal);
+        }
+
+        // LHS: singleton record constructor (arity 0)
+        if let TypedExpr::Var {
+            constructor:
+                ValueConstructor {
+                    variant: ValueConstructorVariant::Record { arity: 0, name, .. },
+                    ..
+                },
+            ..
+        } = left
+        {
+            return self.singleton_equal_helper(right, name, should_be_equal);
+        }
+
         // 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_equal_helper(
+        &mut self,
+        expr: &'a TypedExpr,
+        name: &EcoString,
+        should_be_equal: bool,
+    ) -> Document<'a> {
+        let expr_doc =
+            self.not_in_tail_position(Some(Ordering::Strict), |this| this.wrap_expression(expr));
+        let constructor_name = name.to_doc();
+
+        if should_be_equal {
+            docvec![expr_doc, " instanceof ", constructor_name]
+        } else {
+            docvec!["!(", expr_doc, " instanceof ", constructor_name, ")"]
+        }
+    }
+
     fn equal_with_doc_operands(
         &mut self,
         left: Document<'a>,
@@ -1966,16 +2046,40 @@ 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 { .. });
+                let both_ctor_values = ctor_tag(left).is_some() && ctor_tag(right).is_some();
+
+                if !both_ctor_values {
+                    if is_var(left)
+                        && !looks_like_constructor_alias(left)
+                        && let Some(tag) = ctor_tag(right)
+                    {
+                        let l = self.guard(left);
+                        return if should_be_equal {
+                            docvec![l, " instanceof ", tag.to_doc()]
+                        } else {
+                            docvec!["!(", l, " instanceof ", tag.to_doc(), ")"]
+                        };
+                    }
+                    if is_var(right)
+                        && !looks_like_constructor_alias(right)
+                        && let Some(tag) = ctor_tag(left)
+                    {
+                        let r = self.guard(right);
+                        return if should_be_equal {
+                            docvec![r, " instanceof ", tag.to_doc()]
+                        } else {
+                            docvec!["!(", r, " instanceof ", tag.to_doc(), ")"]
+                        };
+                    }
+                }
 
-            ClauseGuard::NotEquals { left, right, .. } => {
-                let left = self.guard(left);
-                let right = self.guard(right);
-                self.prelude_equal_call(false, left, right)
+                // Otherwise fallback to normal equality check
+                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, .. } => {