refact(es): Remove useless helper(again)

Author: Austaras

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

@@ -1,7 +1,7 @@
 use par_iter::prelude::*;
 use swc_common::{util::take::Take, EqIgnoreSpan, Spanned, DUMMY_SP};
 use swc_ecma_ast::*;
-use swc_ecma_utils::{extract_var_ids, ExprCtx, ExprExt, StmtExt, StmtLike, Value};
+use swc_ecma_utils::{extract_var_ids, ExprCtx, ExprExt, StmtExt, StmtLike, Type, Value};
 use swc_ecma_visit::{noop_visit_type, Visit, VisitWith};
 
 use super::Pure;
@@ -11,62 +11,6 @@ use crate::{
     util::{make_bool, ModuleItemExt},
 };
 
-/// Returns true if completing `expr` always produces a value accepted by
-/// RequireObjectCoercible.
-///
-/// This deliberately recognizes only expression forms whose result is known
-/// from syntax. Calls and identifier references are excluded because their
-/// values can be nullish even when evaluating them has no observable effects.
-fn is_definitely_non_nullish(expr: &Expr) -> bool {
-    match expr {
-        Expr::Paren(ParenExpr { expr, .. }) => is_definitely_non_nullish(expr),
-
-        Expr::Lit(Lit::Null(..))
-        | Expr::Unary(UnaryExpr {
-            op: op!("void"), ..
-        }) => false,
-
-        Expr::Lit(..)
-        | Expr::Array(..)
-        | Expr::Arrow(..)
-        | Expr::Class(..)
-        | Expr::Fn(..)
-        | Expr::New(..)
-        | Expr::Object(..)
-        | Expr::Tpl(..)
-        | Expr::Unary(..)
-        | Expr::Update(..) => true,
-
-        Expr::Assign(AssignExpr {
-            op: op!("="),
-            right,
-            ..
-        }) => is_definitely_non_nullish(right),
-
-        Expr::Bin(BinExpr {
-            op: op!("&&") | op!("||") | op!("??"),
-            left,
-            right,
-            ..
-        }) => is_definitely_non_nullish(left) && is_definitely_non_nullish(right),
-
-        // All other binary operators produce a primitive value if their
-        // operands complete evaluation. Replacing the outer assignment retains
-        // that operand evaluation and any exception it may produce.
-        Expr::Bin(..) => true,
-
-        Expr::Cond(CondExpr { cons, alt, .. }) => {
-            is_definitely_non_nullish(cons) && is_definitely_non_nullish(alt)
-        }
-
-        Expr::Seq(SeqExpr { exprs, .. }) => exprs
-            .last()
-            .is_some_and(|expr| is_definitely_non_nullish(expr)),
-
-        _ => false,
-    }
-}
-
 /// Methods related to option `dead_code`.
 impl Pure<'_> {
     pub(super) fn simplify_assign_expr(&mut self, e: &mut Expr) {
@@ -96,7 +40,11 @@ impl Pure<'_> {
                 ..
             }) if match &*left {
                 AssignTargetPat::Object(obj) => {
-                    obj.props.is_empty() && is_definitely_non_nullish(right)
+                    obj.props.is_empty()
+                        && !matches!(
+                            right.get_type(self.expr_ctx),
+                            Value::Known(Type::Null | Type::Undefined) | Value::Unknown
+                        )
                 }
                 _ => false,
             } =>

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

@@ -17,7 +17,7 @@ use super::Pure;
 use crate::{
     compress::{
         pure::{strings::convert_str_value_to_tpl_raw, Ctx},
-        util::{eval_to_undefined, is_pure_undefined},
+        util::is_pure_undefined,
     },
     usage_analyzer::util::is_global_var_with_pure_property_access,
 };
@@ -61,45 +61,6 @@ fn can_compress_new_regexp(args: Option<&[ExprOrSpread]>) -> bool {
     }
 }
 
-fn may_evaluate_to_nullish(expr_ctx: ExprCtx, expr: &Expr) -> bool {
-    if is_pure_undefined(expr_ctx, expr) || matches!(expr, Expr::Lit(Lit::Null(..))) {
-        return true;
-    }
-
-    match expr {
-        Expr::Paren(ParenExpr { expr, .. }) => may_evaluate_to_nullish(expr_ctx, expr),
-        Expr::Seq(SeqExpr { exprs, .. }) => match exprs.last() {
-            Some(last) => may_evaluate_to_nullish(expr_ctx, last),
-            None => false,
-        },
-        Expr::Cond(CondExpr { cons, alt, .. }) => {
-            may_evaluate_to_nullish(expr_ctx, cons) || may_evaluate_to_nullish(expr_ctx, alt)
-        }
-        _ => matches!(
-            expr.get_type(expr_ctx),
-            Value::Known(Type::Undefined | Type::Null) | Value::Unknown
-        ),
-    }
-}
-
-/// Returns true if evaluating `expr` always produces a nullish value.
-///
-/// Unlike [`is_pure_undefined`], this accepts expressions with effects because
-/// callers can preserve those effects separately.
-fn eval_to_nullish(expr_ctx: ExprCtx, expr: &Expr) -> bool {
-    match expr {
-        Expr::Paren(ParenExpr { expr, .. }) => eval_to_nullish(expr_ctx, expr),
-        Expr::Seq(SeqExpr { exprs, .. }) => exprs
-            .last()
-            .is_some_and(|last| eval_to_nullish(expr_ctx, last)),
-        Expr::Cond(CondExpr { cons, alt, .. }) => {
-            eval_to_nullish(expr_ctx, cons) && eval_to_nullish(expr_ctx, alt)
-        }
-        Expr::Lit(Lit::Null(..)) => true,
-        _ => eval_to_undefined(expr_ctx, expr),
-    }
-}
-
 fn collect_exprs_from_object(obj: &mut ObjectLit) -> Vec<Box<Expr>> {
     let mut exprs = Vec::new();
 
@@ -885,9 +846,10 @@ impl Pure<'_> {
             if !self.options.unsafe_passes
                 && groups.iter().any(|group| match group {
                     GroupType::Literals(_) => false,
-                    GroupType::Expression(expr) => {
-                        may_evaluate_to_nullish(self.expr_ctx, &expr.expr)
-                    }
+                    GroupType::Expression(expr) => matches!(
+                        &expr.expr.get_type(self.expr_ctx,),
+                        Value::Known(Type::Null | Type::Undefined) | Value::Unknown
+                    ),
                 })
             {
                 return None;
@@ -2339,8 +2301,10 @@ impl Pure<'_> {
                         .and_then(|arg| arg.first())
                         .map(|arg| {
                             arg.spread.is_none()
-                                && (eval_to_nullish(self.expr_ctx, &arg.expr)
-                                    || is_valid_map_set_init(&arg.expr, self.expr_ctx, callee))
+                                && (matches!(
+                                    &arg.expr.get_type(self.expr_ctx,),
+                                    Value::Known(Type::Null | Type::Undefined)
+                                ) || is_valid_map_set_init(&arg.expr, self.expr_ctx, callee))
                         })
                         .unwrap_or(true) =>
                 {

crates/swc_ecma_minifier/tests/projects-size.snapshot.md

@@ -1,6 +1,6 @@
 | File | Original Size | Compressed Size | Gzipped Size |
 | --- | --- | --- | --- |
-| angular-1.2.5.js | 757.44 KiB | 101.90 KiB | 37.18 KiB |
+| angular-1.2.5.js | 757.44 KiB | 102.00 KiB | 37.21 KiB |
 | backbone-1.1.0.js | 59.77 KiB | 18.29 KiB | 6.29 KiB |
 | jquery-1.9.1.js | 309.61 KiB | 90.76 KiB | 32.09 KiB |
 | jquery.mobile-1.4.2.js | 534.38 KiB | 191.24 KiB | 52.60 KiB |

crates/swc_ecma_transforms_optimization/src/simplify/branch/mod.rs

@@ -9,7 +9,8 @@ use swc_ecma_ast::*;
 use swc_ecma_transforms_base::perf::{cpu_count, Parallel, ParallelExt};
 use swc_ecma_utils::{
     extract_var_ids, is_literal, prepend_stmt, ExprCtx, ExprExt, ExprFactory, Hoister, IsEmpty,
-    StmtExt, StmtLike, Value::Known,
+    StmtExt, StmtLike, Type,
+    Value::{self, Known},
 };
 use swc_ecma_visit::{
     noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
@@ -62,58 +63,6 @@ struct Remover {
     expr_ctx: ExprCtx,
 }
 
-/// Returns true if completing `expr` always produces a value accepted by
-/// RequireObjectCoercible.
-///
-/// Empty object destructuring still throws for nullish values, so this must
-/// remain conservative when removing the destructuring assignment.
-fn is_definitely_non_nullish(expr: &Expr) -> bool {
-    match expr {
-        Expr::Paren(ParenExpr { expr, .. }) => is_definitely_non_nullish(expr),
-
-        Expr::Lit(Lit::Null(..))
-        | Expr::Unary(UnaryExpr {
-            op: op!("void"), ..
-        }) => false,
-
-        Expr::Lit(..)
-        | Expr::Array(..)
-        | Expr::Arrow(..)
-        | Expr::Class(..)
-        | Expr::Fn(..)
-        | Expr::New(..)
-        | Expr::Object(..)
-        | Expr::Tpl(..)
-        | Expr::Unary(..)
-        | Expr::Update(..) => true,
-
-        Expr::Assign(AssignExpr {
-            op: op!("="),
-            right,
-            ..
-        }) => is_definitely_non_nullish(right),
-
-        Expr::Bin(BinExpr {
-            op: op!("&&") | op!("||") | op!("??"),
-            left,
-            right,
-            ..
-        }) => is_definitely_non_nullish(left) && is_definitely_non_nullish(right),
-
-        Expr::Bin(..) => true,
-
-        Expr::Cond(CondExpr { cons, alt, .. }) => {
-            is_definitely_non_nullish(cons) && is_definitely_non_nullish(alt)
-        }
-
-        Expr::Seq(SeqExpr { exprs, .. }) => exprs
-            .last()
-            .is_some_and(|expr| is_definitely_non_nullish(expr)),
-
-        _ => false,
-    }
-}
-
 impl Parallel for Remover {
     fn create(&self) -> Self {
         Self { ..*self }
@@ -189,7 +138,11 @@ impl VisitMut for Remover {
                 ..
             }) if match &*left {
                 AssignTargetPat::Object(obj) => {
-                    obj.props.is_empty() && is_definitely_non_nullish(right)
+                    obj.props.is_empty()
+                        && !matches!(
+                            right.get_type(self.expr_ctx),
+                            Value::Known(Type::Null | Type::Undefined) | Value::Unknown
+                        )
                 }
                 _ => false,
             } =>

crates/swc_ecma_utils/src/lib.rs

@@ -3346,9 +3346,11 @@ fn get_type(expr: &Expr, ctx: ExprCtx) -> Value<Type> {
             ..
         }) if &**length == "length" => match &**obj {
             Expr::Array(ArrayLit { .. }) | Expr::Lit(Lit::Str(..)) => Known(Type::Num),
-            Expr::Ident(Ident { sym: arguments, .. }) if &**arguments == "arguments" => {
-                Known(Type::Num)
-            }
+            Expr::Ident(Ident {
+                sym: arguments,
+                ctxt,
+                ..
+            }) if &**arguments == "arguments" && *ctxt == ctx.unresolved_ctxt => Known(Type::Num),
             _ => Unknown,
         },
 
@@ -3421,9 +3423,9 @@ fn get_type(expr: &Expr, ctx: ExprCtx) -> Value<Type> {
             Unknown
         }
 
-        Expr::Ident(Ident { ref sym, .. }) => Known(match &**sym {
-            "undefined" => UndefinedType,
-            "NaN" | "Infinity" => NumberType,
+        Expr::Ident(Ident { sym, ctxt, .. }) => Known(match &**sym {
+            "undefined" if *ctxt == ctx.unresolved_ctxt => UndefinedType,
+            "NaN" | "Infinity" if *ctxt == ctx.unresolved_ctxt => NumberType,
             _ => return Unknown,
         }),