feat(es/resolver): Make scope context identical to the vars (#7095)

crates/swc_ecma_minifier/src/lib.rs

@@ -46,7 +46,7 @@ use swc_ecma_usage_analyzer::marks::Marks;
 use swc_ecma_visit::VisitMutWith;
 use swc_timer::timer;
 
-pub use crate::pass::{global_defs::globals_defs, unique_scope::unique_scope};
+pub use crate::pass::global_defs::globals_defs;
 use crate::{
     compress::{compressor, pure_optimizer, PureOptimizerConfig},
     metadata::info_marker,
@@ -178,7 +178,6 @@ pub fn optimize(
         ));
         debug_assert_valid(&n);
     }
-    n.visit_mut_with(&mut unique_scope());
 
     if options.wrap {
         // TODO: wrap_common_js

crates/swc_ecma_minifier/src/pass/mod.rs

@@ -5,4 +5,3 @@ pub mod mangle_props;
 pub mod merge_exports;
 pub mod postcompress;
 pub mod precompress;
-pub mod unique_scope;

crates/swc_ecma_transforms_base/src/resolver/mod.rs

@@ -2,7 +2,7 @@ use rustc_hash::FxHashSet;
 use swc_atoms::{js_word, JsWord};
 use swc_common::{
     collections::{AHashMap, AHashSet},
-    Mark, SyntaxContext,
+    Mark, Span, SyntaxContext,
 };
 use swc_ecma_ast::*;
 use swc_ecma_utils::{find_pat_ids, IsDirective};
@@ -251,18 +251,13 @@ impl<'a> Resolver<'a> {
     }
 
     fn visit_mut_stmt_within_child_scope(&mut self, s: &mut Stmt) {
-        self.with_child(ScopeKind::Block, |child| {
-            child.visit_mut_stmt_within_same_scope(s)
-        });
-    }
-
-    fn visit_mut_stmt_within_same_scope(&mut self, s: &mut Stmt) {
-        match s {
+        self.with_child(ScopeKind::Block, |child| match s {
             Stmt::Block(s) => {
-                s.visit_mut_children_with(self);
+                child.mark_block(&mut s.span);
+                s.visit_mut_children_with(child);
             }
-            _ => s.visit_mut_with(self),
-        }
+            _ => s.visit_mut_with(child),
+        });
     }
 
     /// Returns a [Mark] for an identifier reference.
@@ -374,6 +369,18 @@ impl<'a> Resolver<'a> {
         };
     }
 
+    fn mark_block(&mut self, span: &mut Span) {
+        if span.ctxt() != SyntaxContext::empty() {
+            return;
+        }
+
+        let mark = self.current.mark;
+
+        if mark != Mark::root() {
+            *span = span.apply_mark(mark)
+        }
+    }
+
     fn try_resolving_as_type(&mut self, i: &mut Ident) {
         if i.span.ctxt.outer() == self.config.unresolved_mark {
             i.span.ctxt = SyntaxContext::empty()
@@ -542,20 +549,21 @@ impl<'a> VisitMut for Resolver<'a> {
             e.params.visit_mut_with(child);
             child.ident_type = old;
 
-            {
-                match &mut *e.body {
-                    BlockStmtOrExpr::BlockStmt(s) => {
-                        let old_strict_mode = child.strict_mode;
-                        child.strict_mode = s
-                            .stmts
-                            .first()
-                            .map(|stmt| stmt.is_use_strict())
-                            .unwrap_or(false);
-                        s.stmts.visit_mut_with(child);
-                        child.strict_mode = old_strict_mode;
-                    }
-                    BlockStmtOrExpr::Expr(e) => e.visit_mut_with(child),
+            match &mut *e.body {
+                BlockStmtOrExpr::BlockStmt(s) => {
+                    child.mark_block(&mut s.span);
+
+                    let old_strict_mode = child.strict_mode;
+                    child.strict_mode = s
+                        .stmts
+                        .first()
+                        .map(|stmt| stmt.is_use_strict())
+                        .unwrap_or(false);
+                    // Prevent creating new scope.
+                    s.stmts.visit_mut_with(child);
+                    child.strict_mode = old_strict_mode;
                 }
+                BlockStmtOrExpr::Expr(e) => e.visit_mut_with(child),
             }
 
             e.return_type.visit_mut_with(child);
@@ -586,18 +594,11 @@ impl<'a> VisitMut for Resolver<'a> {
 
     fn visit_mut_block_stmt(&mut self, block: &mut BlockStmt) {
         self.with_child(ScopeKind::Block, |child| {
+            child.mark_block(&mut block.span);
             block.visit_mut_children_with(child);
         })
     }
 
-    /// Handle body of the arrow functions
-    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
-        match node {
-            BlockStmtOrExpr::BlockStmt(block) => block.visit_mut_children_with(self),
-            BlockStmtOrExpr::Expr(e) => e.visit_mut_with(self),
-        }
-    }
-
     fn visit_mut_break_stmt(&mut self, s: &mut BreakStmt) {
         let old = self.ident_type;
         self.ident_type = IdentType::Label;
@@ -613,6 +614,7 @@ impl<'a> VisitMut for Resolver<'a> {
             c.param.visit_mut_with(child);
             child.ident_type = IdentType::Ref;
 
+            child.mark_block(&mut c.body.span);
             c.body.visit_mut_children_with(child);
         });
     }
@@ -716,6 +718,7 @@ impl<'a> VisitMut for Resolver<'a> {
 
             match &mut c.body {
                 Some(body) => {
+                    child.mark_block(&mut body.span);
                     body.visit_mut_children_with(child);
                 }
                 None => {}
@@ -730,10 +733,6 @@ impl<'a> VisitMut for Resolver<'a> {
         self.ident_type = old;
     }
 
-    fn visit_mut_decl(&mut self, decl: &mut Decl) {
-        decl.visit_mut_children_with(self)
-    }
-
     fn visit_mut_export_default_decl(&mut self, e: &mut ExportDefaultDecl) {
         // Treat default exported functions and classes as declarations
         // even though they are parsed as expressions.
@@ -799,7 +798,7 @@ impl<'a> VisitMut for Resolver<'a> {
     }
 
     fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
-        // We don't fold this as Hoister handles this.
+        // We don't fold ident as Hoister handles this.
 
         node.function.decorators.visit_mut_with(self);
 
@@ -855,6 +854,7 @@ impl<'a> VisitMut for Resolver<'a> {
     }
 
     fn visit_mut_function(&mut self, f: &mut Function) {
+        self.mark_block(&mut f.span);
         f.type_params.visit_mut_with(self);
 
         self.ident_type = IdentType::Ref;
@@ -880,6 +880,7 @@ impl<'a> VisitMut for Resolver<'a> {
         self.ident_type = IdentType::Ref;
         match &mut f.body {
             Some(body) => {
+                self.mark_block(&mut body.span);
                 let old_strict_mode = self.strict_mode;
                 self.strict_mode = body
                     .stmts

crates/swc_ecma_transforms_base/tests/resolver/babel/issue/973/output.js

@@ -1,6 +1,6 @@
 let arr__1 = [];
 for(let i__2 = 0; i__2 < 10; i__2++){
-    for(let i__3 = 0; i__3 < 10; i__3++){
-        arr__1.push(()=>i__3);
+    for(let i__4 = 0; i__4 < 10; i__4++){
+        arr__1.push(()=>i__4);
     }
 }

crates/swc_ecma_transforms_base/tests/resolver/basic/1/output.js

@@ -1,8 +1,8 @@
 {
     var foo__1 = 1;
     {
-        let foo__2 = 2;
-        use(foo__2);
+        let foo__3 = 2;
+        use(foo__3);
     }
     use(foo__1);
 }

crates/swc_ecma_transforms_base/tests/resolver/block/scope/class/output.js

@@ -1,9 +1,9 @@
 const g__1 = 20;
 function baz__1() {
     {
-        class g__2 {
+        class g__3 {
         }
-        console.log(g__2);
+        console.log(g__3);
     }
     return g__1;
 }

crates/swc_ecma_transforms_base/tests/resolver/export/default/fn_decl/scope/output.js

@@ -1,6 +1,6 @@
 export default function foo__1() {
-    foo__1 = function foo__2(x__3) {
-        return x__3 === 0 ? 1 : 1 + foo__2(x__3 - 1);
+    foo__1 = function foo__3(x__4) {
+        return x__4 === 0 ? 1 : 1 + foo__3(x__4 - 1);
     };
     return foo__1(10);
 }

crates/swc_ecma_transforms_base/tests/resolver/fn_expr/scope/output.js

@@ -1,6 +1,6 @@
 test(function foo__2() {
-    foo__2 = function foo__3(x__4) {
-        return x__4 === 0 ? 1 : 1 + foo__3(x__4 - 1);
+    foo__2 = function foo__4(x__5) {
+        return x__5 === 0 ? 1 : 1 + foo__4(x__5 - 1);
     };
     return foo__2(10);
 });

crates/swc_ecma_transforms_base/tests/resolver/function/hoist/output.js

@@ -8,30 +8,30 @@ function foo__1() {
     console.log(r__2());
 }
 function bar__1() {
-    var r__5 = ()=>1;
+    var r__6 = ()=>1;
     if (true) {
-        function r__5() {
+        function r__6() {
             return 2;
         }
     }
-    console.log(r__5());
+    console.log(r__6());
 }
 function baz__1() {
-    function r__6() {
+    function r__9() {
         return 1;
     }
     if (true) {
-        function r__6() {
+        function r__9() {
             return 2;
         }
     }
-    console.log(r__6());
+    console.log(r__9());
 }
-function quz__1(r__7 = ()=>1) {
+function quz__1(r__13 = ()=>1) {
     if (true) {
-        function r__8() {
+        function r__14() {
             return 2;
         }
     }
-    console.log(r__7());
+    console.log(r__13());
 }

crates/swc_ecma_transforms_base/tests/resolver/general/assignment/patterns/output.js

@@ -1,12 +1,12 @@
 const foo__1 = "foo";
 function foobar__1() {
-    for (let item__2 of [
+    for (let item__3 of [
         1,
         2,
         3
     ]){
-        let foo__3 = "bar";
-        [bar, foo__3] = [
+        let foo__4 = "bar";
+        [bar, foo__4] = [
             1,
             2
         ];

crates/swc_ecma_transforms_base/tests/resolver/issue-4953/output.js

@@ -5,7 +5,7 @@ export default function(module__1, exports__1) {
     }(void 0, function(t__3) {
         "use strict";
         function vr__3(e__4, r__4, o__4) {
-            try {} catch (t__5) {}
+            try {} catch (t__6) {}
             function t__4() {
                 return '123';
             }

crates/swc_ecma_transforms_base/tests/resolver/issues/1402/output.js

@@ -1,6 +1,6 @@
 var e__1 = 1;
 try {
     throw 2;
-} catch (e__2) {
-    console.log(e__2);
+} catch (e__3) {
+    console.log(e__3);
 }

crates/swc_ecma_transforms_base/tests/resolver/issues/281/2/output.js

@@ -1,6 +1,6 @@
 function foo__1(e__2) {
     e__0: {
-        try {} catch (e1__3) {
+        try {} catch (e1__5) {
             o = null;
             break e__0;
         }

crates/swc_ecma_transforms_base/tests/resolver/issues/2854/1/output.js

@@ -1,8 +1,8 @@
 export function App__1() {
     return <Form__1/>;
 }
-export function Form__1({ onChange__2 =function() {}  }) {
+export function Form__1({ onChange__3 =function() {}  }) {
     return <input onChange__0={function() {
-        onChange__2();
+        onChange__3();
     }}/>;
 }

crates/swc_ecma_transforms_base/tests/resolver/issues/292/1/output.js

@@ -1,10 +1,10 @@
 var __assign__1 = function() {
-    __assign__1 = Object.assign || function __assign1__3(t__4) {
-        for(var s__4, i__4 = 1, n__4 = arguments.length; i__4 < n__4; i__4++){
-            s__4 = arguments[i__4];
-            for(var p__4 in s__4)if (Object.prototype.hasOwnProperty.call(s__4, p__4)) t__4[p__4] = s__4[p__4];
+    __assign__1 = Object.assign || function __assign1__4(t__5) {
+        for(var s__5, i__5 = 1, n__5 = arguments.length; i__5 < n__5; i__5++){
+            s__5 = arguments[i__5];
+            for(var p__5 in s__5)if (Object.prototype.hasOwnProperty.call(s__5, p__5)) t__5[p__5] = s__5[p__5];
         }
-        return t__4;
+        return t__5;
     };
     return __assign__1.apply(this, arguments);
 };

crates/swc_ecma_transforms_base/tests/resolver/issues/369/2/output.js

@@ -1,7 +1,7 @@
 function a__1() {}
 function b__1() {}
-function foo__1({ a: b__2  }) {
-    expect(b__2).toBe("a");
+function foo__1({ a: b__4  }) {
+    expect(b__4).toBe("a");
 }
 foo__1({
     a: "a"

crates/swc_ecma_transforms_base/tests/resolver/issues/454/1/output.js

@@ -3,6 +3,6 @@ function foo__1() {
     try {
         var a__2 = 1;
         a__2;
-    } catch (err__3) {}
+    } catch (err__4) {}
     a__2;
 }