fix(es/compat): Fix new.target in a nested scope (#6296)

crates/swc/tests/tsc-references/newTarget.es5.1.normal.js

@@ -5,14 +5,14 @@ import _instanceof from "@swc/helpers/src/_instanceof.mjs";
 import _create_super from "@swc/helpers/src/_create_super.mjs";
 var A = function A() {
     "use strict";
-    var _newtarget = _instanceof(this, A) ? this.constructor : void 0;
+    var _this = this;
     _class_call_check(this, A);
     this.d = function _target() {
         return _instanceof(this, _target) ? this.constructor : void 0;
     };
     var a = _instanceof(this, A) ? this.constructor : void 0;
     var b = function() {
-        return _newtarget;
+        return _instanceof(_this, A) ? _this.constructor : void 0;
     };
 };
 A.c = function _target() {
@@ -23,29 +23,29 @@ var B = /*#__PURE__*/ function _target(A) {
     _inherits(B, A);
     var _super = _create_super(B);
     function B() {
-        var _newtarget = _instanceof(this, B) ? this.constructor : void 0;
+        var _this = this;
         _class_call_check(this, B);
-        var _this = _super.call(this);
+        var _this1 = _super.call(this);
         var e = _instanceof(this, B) ? this.constructor : void 0;
         var f = function() {
-            return _newtarget;
+            return _instanceof(_this, B) ? _this.constructor : void 0;
         };
-        return _this;
+        return _this1;
     }
     return B;
 }(A);
 function f1() {
-    var _newtarget = _instanceof(this, f1) ? this.constructor : void 0;
+    var _this = this;
     var g = _instanceof(this, f1) ? this.constructor : void 0;
     var h = function() {
-        return _newtarget;
+        return _instanceof(_this, f1) ? _this.constructor : void 0;
     };
 }
 var f2 = function _target() {
-    var _newtarget = _instanceof(this, _target) ? this.constructor : void 0;
+    var _this = this;
     var i = _instanceof(this, _target) ? this.constructor : void 0;
     var j = function() {
-        return _newtarget;
+        return _instanceof(_this, _target) ? _this.constructor : void 0;
     };
 };
 var O = {

crates/swc_ecma_transforms_compat/src/es2015/new_target.rs

@@ -1,142 +1,85 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, mem};
 
 use swc_common::{pass::CompilerPass, DUMMY_SP};
 use swc_ecma_ast::*;
 use swc_ecma_transforms_base::perf::{should_work, Check};
-use swc_ecma_utils::{prepend_stmt, private_ident, quote_ident, undefined, ExprFactory};
+use swc_ecma_utils::{private_ident, quote_ident, undefined, ExprFactory};
 use swc_ecma_visit::{
     as_folder, noop_visit_mut_type, noop_visit_type, Fold, Visit, VisitMut, VisitMutWith,
 };
 use swc_trace_macro::swc_trace;
 
 #[tracing::instrument(level = "info", skip_all)]
 pub fn new_target() -> impl Fold + VisitMut + CompilerPass {
-    as_folder(NewTarget::default())
+    as_folder(NewTarget {
+        ctx: Ctx::Constructor,
+    })
 }
 
-#[derive(Default)]
-
 struct NewTarget {
-    cur: Option<Ident>,
-
-    in_constructor: bool,
-    in_method: bool,
-    in_arrow_expr: bool,
+    ctx: Ctx,
+}
 
-    var: Option<VarDeclarator>,
+enum Ctx {
+    Constructor,
+    Method,
+    Function(Ident),
 }
 
 impl NewTarget {
     fn visit_mut_method<T: VisitMutWith<Self>>(&mut self, c: &mut T) {
-        let old = self.in_method;
-
-        self.in_method = true;
+        let old = mem::replace(&mut self.ctx, Ctx::Method);
 
         c.visit_mut_with(self);
 
-        self.in_method = old;
+        self.ctx = old;
     }
 }
 
 #[swc_trace]
 impl VisitMut for NewTarget {
     noop_visit_mut_type!();
 
-    fn visit_mut_arrow_expr(&mut self, e: &mut ArrowExpr) {
-        // Ensure that `e` contains new.target
-        if !should_work::<ShouldWork, _>(&*e) {
-            return;
-        }
-
-        let old = self.in_arrow_expr;
-        if self.var.is_none() {
-            let mut v = Expr::MetaProp(MetaPropExpr {
-                span: DUMMY_SP,
-                kind: MetaPropKind::NewTarget,
-            });
-            v.visit_mut_with(self);
-            self.var.get_or_insert_with(|| VarDeclarator {
-                span: DUMMY_SP,
-                name: private_ident!("_newtarget").into(),
-                init: Some(Box::new(v)),
-                definite: Default::default(),
-            });
-        }
-        self.in_arrow_expr = true;
-        e.visit_mut_children_with(self);
-
-        self.in_arrow_expr = old;
-    }
-
-    fn visit_mut_class_decl(&mut self, class: &mut ClassDecl) {
-        let old = self.cur.take();
-        self.cur = Some(class.ident.clone());
-
-        class.visit_mut_children_with(self);
-
-        self.cur = old;
-    }
-
-    fn visit_mut_class_expr(&mut self, class: &mut ClassExpr) {
-        let old = self.cur.take();
-        self.cur = class.ident.clone();
-
-        class.visit_mut_children_with(self);
-
-        self.cur = old;
-    }
-
     fn visit_mut_class_method(&mut self, c: &mut ClassMethod) {
         c.key.visit_mut_with(self);
 
         self.visit_mut_method(&mut c.function)
     }
 
     fn visit_mut_constructor(&mut self, c: &mut Constructor) {
-        let old = self.in_constructor;
-
-        self.in_constructor = true;
-        self.in_arrow_expr = false;
-        self.var = None;
+        let old = mem::replace(&mut self.ctx, Ctx::Constructor);
 
         c.visit_mut_children_with(self);
 
-        self.in_constructor = old;
+        self.ctx = old;
     }
 
     fn visit_mut_expr(&mut self, e: &mut Expr) {
         e.visit_mut_children_with(self);
 
         if let Expr::MetaProp(MetaPropExpr {
             kind: MetaPropKind::NewTarget,
-            ..
+            span,
         }) = e
         {
-            if self.in_arrow_expr {
-                *e = Expr::Ident(self.var.as_ref().unwrap().name.clone().ident().unwrap().id);
-            } else if self.in_method {
-                *e = *undefined(DUMMY_SP)
-            } else if let Some(cur) = self.cur.clone() {
-                let c = ThisExpr { span: DUMMY_SP }.make_member(quote_ident!("constructor"));
-
-                if self.in_constructor {
-                    *e = c;
-                } else {
-                    // (this instanceof Foo ? this.constructor : void 0)
+            let this_ctor = |span| ThisExpr { span }.make_member(quote_ident!("constructor"));
+            match &self.ctx {
+                Ctx::Constructor => *e = this_ctor(*span),
+                Ctx::Method => *e = *undefined(DUMMY_SP),
+                Ctx::Function(i) => {
                     *e = Expr::Cond(CondExpr {
-                        span: DUMMY_SP,
+                        span: *span,
                         // this instanceof Foo
                         test: Box::new(Expr::Bin(BinExpr {
                             span: DUMMY_SP,
                             op: op!("instanceof"),
                             left: Box::new(Expr::This(ThisExpr { span: DUMMY_SP })),
-                            right: Box::new(Expr::Ident(cur)),
+                            right: Box::new(Expr::Ident(i.clone())),
                         })),
-                        // this.constructor
-                        cons: Box::new(c),
+                        cons: Box::new(this_ctor(DUMMY_SP)),
                         // void 0
                         alt: undefined(DUMMY_SP),
-                    });
+                    })
                 }
             }
         }
@@ -148,12 +91,11 @@ impl VisitMut for NewTarget {
             return;
         }
 
-        let old = self.cur.take();
-        self.cur = Some(f.ident.clone());
+        let old = mem::replace(&mut self.ctx, Ctx::Function(f.ident.clone()));
 
         f.visit_mut_children_with(self);
 
-        self.cur = old;
+        self.ctx = old;
     }
 
     fn visit_mut_fn_expr(&mut self, f: &mut FnExpr) {
@@ -167,12 +109,11 @@ impl VisitMut for NewTarget {
             .get_or_insert_with(|| private_ident!("_target"))
             .clone();
 
-        let old = self.cur.take();
-        self.cur = Some(i);
+        let old = mem::replace(&mut self.ctx, Ctx::Function(i));
 
         f.visit_mut_children_with(self);
 
-        self.cur = old;
+        self.ctx = old;
     }
 
     fn visit_mut_method_prop(&mut self, m: &mut MethodProp) {
@@ -189,42 +130,6 @@ impl VisitMut for NewTarget {
         m.key.visit_mut_with(self);
         self.visit_mut_method(&mut m.body)
     }
-
-    fn visit_mut_module_items(&mut self, stmts: &mut Vec<ModuleItem>) {
-        stmts.visit_mut_children_with(self);
-
-        if let Some(var) = self.var.take() {
-            prepend_stmt(
-                stmts,
-                VarDecl {
-                    span: DUMMY_SP,
-                    kind: VarDeclKind::Var,
-                    declare: false,
-                    decls: vec![var],
-                }
-                .into(),
-            )
-        }
-    }
-
-    fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
-        stmts.visit_mut_children_with(self);
-
-        if !self.in_arrow_expr {
-            if let Some(var) = self.var.take() {
-                prepend_stmt(
-                    stmts,
-                    VarDecl {
-                        span: DUMMY_SP,
-                        kind: VarDeclKind::Var,
-                        declare: false,
-                        decls: vec![var],
-                    }
-                    .into(),
-                )
-            }
-        }
-    }
 }
 
 impl CompilerPass for NewTarget {