pref(es/minifier): less get_type

Author: bvanjoi

crates/swc_ecma_minifier/src/compress/pure/bools.rs

@@ -243,36 +243,32 @@ impl Pure<'_> {
     }
 
     pub(super) fn compress_cmp_with_long_op(&mut self, e: &mut BinExpr) {
-        fn should_optimize(l: &Expr, r: &Expr, ctx: ExprCtx, opts: &CompressOptions) -> bool {
-            match (l, r) {
+        if !matches!(e.op, op!("===") | op!("!==")) {
+            return;
+        }
+
+        let is_typeof_unaray = |l: &Expr, r: &Expr| {
+            matches!(
+                (l, r),
                 (
                     Expr::Unary(UnaryExpr {
-                        op: op!("typeof"), ..
+                        op: op!("typeof"),
+                        ..
                     }),
-                    Expr::Lit(..),
-                ) => true,
-                _ => {
-                    if opts.comparisons {
-                        match (l.get_type(ctx), r.get_type(ctx)) {
-                            (Value::Known(lt), Value::Known(rt)) => lt == rt,
-
-                            _ => false,
-                        }
-                    } else {
-                        false
-                    }
-                }
-            }
-        }
+                    Expr::Lit(..)
+                )
+            )
+        };
 
-        match e.op {
-            op!("===") | op!("!==") => {}
-            _ => return,
-        }
+        let should_optimize = is_typeof_unaray(&e.left, &e.right)
+            || is_typeof_unaray(&e.right, &e.left)
+            || (self.options.comparisons
+                && matches!(
+                    (e.left.get_type(self.expr_ctx), e.right.get_type(self.expr_ctx)),
+                    (Value::Known(l), Value::Known(r)) if l == r
+                ));
 
-        if should_optimize(&e.left, &e.right, self.expr_ctx, self.options)
-            || should_optimize(&e.right, &e.left, self.expr_ctx, self.options)
-        {
+        if should_optimize {
             report_change!("bools: Compressing comparison of `typeof` with literal");
             self.changed = true;
             e.op = match e.op {