hoist var decl

bvanjoi · bvanjoi · commit f7a6df1ef2ad · 2025-08-14T16:59:39.000+08:00
diff --git a/crates/swc_ecma_ast/src/expr.rs b/crates/swc_ecma_ast/src/expr.rs
@@ -1575,12 +1575,10 @@ impl TryFrom<Box<Expr>> for SimpleAssignTarget {
 bridge_from!(SimpleAssignTarget, BindingIdent, Ident);
 
 impl SimpleAssignTarget {
-    pub fn leftmost(&self) -> Option<Cow<Ident>> {
+    pub fn leftmost(&self) -> Option<&Ident> {
         match self {
-            SimpleAssignTarget::Ident(i) => {
-                Some(Cow::Owned(Ident::new(i.sym.clone(), i.span, i.ctxt)))
-            }
-            SimpleAssignTarget::Member(MemberExpr { obj, .. }) => obj.leftmost().map(Cow::Borrowed),
+            SimpleAssignTarget::Ident(i) => Some(&i.id),
+            SimpleAssignTarget::Member(MemberExpr { obj, .. }) => obj.leftmost(),
             _ => None,
         }
     }
diff --git a/crates/swc_ecma_minifier/src/compress/optimize/mod.rs b/crates/swc_ecma_minifier/src/compress/optimize/mod.rs
@@ -241,7 +241,7 @@ struct Optimizer<'a> {
     ctx: Ctx,
 
     mode: &'a dyn Mode,
-    r: &'a Resolver,
+    r: &'a mut Resolver,
 
     functions: Box<FxHashMap<Id, FnMetadata>>,
 }
diff --git a/crates/swc_ecma_minifier/src/compress/optimize/props.rs b/crates/swc_ecma_minifier/src/compress/optimize/props.rs
@@ -1,5 +1,6 @@
 use swc_common::{util::take::Take, DUMMY_SP};
 use swc_ecma_ast::*;
+use swc_ecma_transforms_base::resolve::RefTo;
 use swc_ecma_utils::{contains_this_expr, private_ident, prop_name_eq, ExprExt};
 
 use super::{unused::PropertyAccessOpts, BitCtx, Optimizer};
@@ -164,18 +165,25 @@ impl Optimizer<'_> {
                     _ => unreachable!(),
                 };
 
-                let new_var_name = private_ident!(format!("{}_{}", name.id.sym, suffix));
+                let mut new_var_name_ident = private_ident!(format!("{}_{}", name.id.sym, suffix));
+                let new_var_decl_name_id = name.id.node_id;
+                self.r
+                    .add_reference_map(&mut new_var_name_ident, new_var_decl_name_id);
 
                 let new_var = VarDeclarator {
                     span: DUMMY_SP,
-                    name: new_var_name.clone().into(),
+                    name: {
+                        let mut n = new_var_name_ident.clone();
+                        n.node_id = new_var_decl_name_id;
+                        n.into()
+                    },
                     init: Some(value),
                     definite: false,
                 };
 
                 self.vars
                     .hoisted_props
-                    .insert((name.node_id, key), new_var_name);
+                    .insert((name.node_id, key), new_var_name_ident);
 
                 new_vars.push(new_var);
             }
@@ -207,10 +215,16 @@ impl Optimizer<'_> {
                 _ => return,
             };
 
+            let node_id = match self.r.find_binding_by_ident(obj) {
+                RefTo::Binding(id) => id,
+                RefTo::Unresolved => return,
+                RefTo::Itself => unreachable!(),
+            };
+            debug_assert!(node_id != obj.node_id);
             if let Some(value) = self
                 .vars
                 .hoisted_props
-                .get(&(obj.node_id, sym.clone()))
+                .get(&(node_id, sym.clone()))
                 .cloned()
             {
                 report_change!("hoist_props: Inlining `{}.{}`", obj.sym, sym);
diff --git a/crates/swc_ecma_transforms_base/src/resolve/mod.rs b/crates/swc_ecma_transforms_base/src/resolve/mod.rs
@@ -11,6 +11,7 @@ use self::{
     reference::ReferenceMap,
     scope::{ScopeArena, ScopeId},
 };
+use crate::resolve::scope::ScopeKind;
 
 #[derive(Debug)]
 pub struct Resolver {
@@ -20,8 +21,6 @@ pub struct Resolver {
     current_scope_id: ScopeId,
 
     current_node_id: u32,
-
-    in_binding: bool,
 }
 
 pub fn name_resolution(root: &mut impl VisitMutWith<Resolver>) -> Resolver {
@@ -35,8 +34,6 @@ pub fn name_resolution(root: &mut impl VisitMutWith<Resolver>) -> Resolver {
 
         scopes,
         current_scope_id,
-
-        in_binding: false,
     };
 
     root.visit_mut_with(&mut resolver);
@@ -52,6 +49,13 @@ impl Resolver {
     pub fn find_binding_by_ident(&self, ident: &Ident) -> RefTo {
         self.references.get_binding(ident.node_id)
     }
+
+    pub fn add_reference_map(&mut self, from: &mut Ident, to: NodeId) {
+        debug_assert!(from.node_id == NodeId::DUMMY);
+        debug_assert!(to != NodeId::DUMMY);
+        from.node_id = self.next_node_id();
+        self.references.add_reference(from.node_id, to);
+    }
 }
 
 impl Resolver {
@@ -61,16 +65,21 @@ impl Resolver {
         ret
     }
 
-    fn add_binding(&mut self, node: &mut Ident) {
-        let id = self.next_node_id();
-        debug_assert!(node.node_id == NodeId::DUMMY);
-        node.node_id = id;
+    fn add_binding(&mut self, id: NodeId, sym: Atom) {
+        debug_assert!(id != NodeId::DUMMY);
         self.scopes
             .get_mut(self.current_scope_id)
-            .add_binding(node.sym.clone(), id);
+            .add_binding(sym, id);
         self.references.add_binding(id);
     }
 
+    fn add_binding_for_ident(&mut self, node: &mut Ident) {
+        let id = self.next_node_id();
+        debug_assert!(node.node_id == NodeId::DUMMY);
+        node.node_id = id;
+        self.add_binding(id, node.sym.clone());
+    }
+
     fn add_reference(&mut self, node: &mut Ident, to: NodeId) {
         let id = self.next_node_id();
         debug_assert!(node.node_id == NodeId::DUMMY);
@@ -98,15 +107,85 @@ impl Resolver {
             scope_id = parent;
         }
     }
+
+    fn with_new_scope(&mut self, kind: ScopeKind, f: impl FnOnce(&mut Self)) {
+        let saved_scope_id = self.current_scope_id;
+        self.current_scope_id = self.scopes.alloc_new_scope(self.current_scope_id, kind);
+        f(self);
+        self.current_scope_id = saved_scope_id;
+    }
+
+    fn visit_pat_with_binding(&mut self, pat: &mut Pat, is_var: bool) {
+        let hoist = |this: &mut Self, atom: &Atom, id: NodeId| {
+            if !is_var {
+                return;
+            }
+            let mut scope_id = this.current_scope_id;
+            loop {
+                let Some(parent) = this.scopes.get(scope_id).parent() else {
+                    return;
+                };
+
+                let s = this.scopes.get_mut(parent);
+                s.add_binding(atom.clone(), id);
+                if !matches!(s.kind(), ScopeKind::Block) {
+                    return;
+                }
+                scope_id = parent;
+            }
+        };
+        match pat {
+            Pat::Ident(n) => {
+                self.add_binding_for_ident(n);
+                hoist(self, &n.sym, n.node_id);
+            }
+            Pat::Array(n) => {
+                for elem in n.elems.iter_mut() {
+                    if let Some(elem) = elem {
+                        self.visit_pat_with_binding(elem, is_var);
+                    }
+                }
+            }
+            Pat::Rest(n) => {
+                self.visit_pat_with_binding(&mut n.arg, is_var);
+            }
+            Pat::Object(n) => {
+                for prop in n.props.iter_mut() {
+                    match prop {
+                        ObjectPatProp::KeyValue(p) => {
+                            self.visit_pat_with_binding(&mut p.value, is_var);
+                        }
+                        ObjectPatProp::Assign(p) => {
+                            self.add_binding_for_ident(&mut p.key.id);
+                            hoist(self, &p.key.sym, p.key.node_id);
+                            p.value.visit_mut_children_with(self);
+                        }
+                        ObjectPatProp::Rest(p) => {
+                            self.visit_pat_with_binding(&mut p.arg, is_var);
+                        }
+                    }
+                }
+            }
+            Pat::Assign(n) => {
+                // TODO:
+                self.visit_pat_with_binding(&mut n.left, is_var);
+                n.right.visit_mut_children_with(self);
+            }
+            Pat::Invalid(n) => {
+                // TODO:
+            }
+            Pat::Expr(n) => {
+                // TODO:
+            }
+        }
+    }
 }
 
 impl VisitMut for Resolver {
     noop_visit_mut_type!();
 
     fn visit_mut_ident(&mut self, node: &mut Ident) {
-        if self.in_binding {
-            self.add_binding(node);
-        } else if let Some(reference) = self.lookup_binding(&node.sym, self.current_scope_id) {
+        if let Some(reference) = self.lookup_binding(&node.sym, self.current_scope_id) {
             self.add_reference(node, reference);
         } else {
             // TODO: unnecessary to mark all ident to unresolved,
@@ -115,13 +194,49 @@ impl VisitMut for Resolver {
         }
     }
 
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
-        let saved_in_binding = self.in_binding;
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
+        for decl in &mut node.decls {
+            self.visit_pat_with_binding(&mut decl.name, node.kind == VarDeclKind::Var);
+            decl.init.visit_mut_children_with(self);
+        }
+    }
 
-        self.in_binding = true;
-        node.name.visit_mut_children_with(self);
-        self.in_binding = saved_in_binding;
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
+        self.with_new_scope(ScopeKind::Block, |this| {
+            node.visit_mut_children_with(this);
+        });
+    }
+
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
+        self.add_binding_for_ident(&mut node.ident);
+
+        self.with_new_scope(ScopeKind::Fn, |this| {
+            node.function.visit_mut_children_with(this);
+        });
+    }
+
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
+        self.with_new_scope(ScopeKind::Fn, |this| {
+            if let Some(ident) = &mut node.ident {
+                this.add_binding_for_ident(ident);
+            }
+            node.function.visit_mut_children_with(this);
+        });
+    }
+
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
+        self.with_new_scope(ScopeKind::Fn, |this| {
+            for param in &mut node.params {
+                this.visit_pat_with_binding(param, false);
+            }
+            node.body.visit_mut_children_with(this);
+        });
+    }
 
-        node.init.visit_mut_children_with(self);
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
+        self.add_binding_for_ident(&mut node.ident);
+        self.with_new_scope(ScopeKind::Class, |this| {
+            node.class.visit_mut_children_with(this);
+        });
     }
 }
diff --git a/crates/swc_ecma_transforms_base/src/resolve/scope.rs b/crates/swc_ecma_transforms_base/src/resolve/scope.rs
@@ -6,6 +6,15 @@ use swc_common::NodeId;
 pub(super) struct Scope {
     parent: Option<ScopeId>,
     bindings: IndexMap<Atom, NodeId>,
+    kind: ScopeKind,
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+pub(super) enum ScopeKind {
+    #[default]
+    Block,
+    Fn,
+    Class,
 }
 
 impl Scope {
@@ -20,6 +29,10 @@ impl Scope {
     pub(super) fn parent(&self) -> Option<ScopeId> {
         self.parent
     }
+
+    pub(super) fn kind(&self) -> ScopeKind {
+        self.kind
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -39,6 +52,17 @@ impl ScopeArena {
         ScopeId::ROOT
     }
 
+    pub(super) fn alloc_new_scope(&mut self, parent: ScopeId, kind: ScopeKind) -> ScopeId {
+        debug_assert!(parent.0 < self.0.len() as u32);
+        let id = ScopeId(self.0.len() as u32);
+        self.0.push(Scope {
+            parent: Some(parent),
+            bindings: IndexMap::new(),
+            kind,
+        });
+        id
+    }
+
     pub(super) fn get(&self, id: ScopeId) -> &Scope {
         debug_assert!(id.0 < self.0.len() as u32);
         unsafe { self.0.get_unchecked(id.0 as usize) }
diff --git a/crates/swc_ecma_usage_analyzer/src/analyzer/mod.rs b/crates/swc_ecma_usage_analyzer/src/analyzer/mod.rs
@@ -438,7 +438,13 @@ where
 
         if let Callee::Expr(callee) = &n.callee {
             for_each_id_ref_in_expr(callee, &mut |i| {
-                self.data.var_or_default(i.node_id).mark_used_as_callee();
+                let node_id = match self.r.find_binding_by_ident(i) {
+                    RefTo::Binding(node_id) => node_id,
+                    RefTo::Unresolved => return,
+                    RefTo::Itself => unreachable!(),
+                };
+                debug_assert!(node_id != i.node_id);
+                self.data.var_or_default(node_id).mark_used_as_callee();
             });
 
             match &**callee {
@@ -1045,6 +1051,7 @@ where
                 RefTo::Unresolved => return,
                 RefTo::Itself => unreachable!(),
             };
+            debug_assert!(node_id != obj.node_id);
             let v = self.data.var_or_default(node_id);
             v.mark_has_property_access();
 

Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ struct Optimizer<'a> {`
`241`	`241`	`ctx: Ctx,`
`242`	`242`
`243`	`243`	`mode: &'a dyn Mode,`
`244`		`- r: &'a Resolver,`
	`244`	`+ r: &'a mut Resolver,`
`245`	`245`
`246`	`246`	`functions: Box<FxHashMap<Id, FnMetadata>>,`
`247`	`247`	`}`