Fix async arrow this capture in static field emit (#4103)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: jakebailey <5341706+jakebailey@users.noreply.github.com>

Author: Copilot

internal/printer/emitflags.go

@@ -27,6 +27,7 @@ const (
 	EFAsyncFunctionBody                                    // The node was originally an async function body.
 	EFNoLexicalArguments                                   // Do not capture `arguments` for this arrow function. Set on arrows lowered from class static blocks, where `arguments` is an error; preserves Strada's emit behavior.
 	EFTransformPrivateStaticElements                       // Indicates static private elements in a file or class should be transformed regardless of --target (used by esDecorators transform).
+	EFNoLexicalThis                                        // Do not capture `this` for this node's subtree. Set on relocated static initializers, where `this` is handled by the class fields transform.
 )
 
 const (

internal/transformers/estransforms/async.go

@@ -136,6 +136,11 @@ func (tx *asyncTransformer) visit(node *ast.Node) *ast.Node {
 	cleanup := tx.descendInto(node)
 	defer cleanup()
 
+	if tx.EmitContext().EmitFlags(node)&printer.EFNoLexicalThis != 0 && tx.inHasLexicalThisContext() {
+		tx.setContextFlag(asyncContextHasLexicalThis, false)
+		defer tx.setContextFlag(asyncContextHasLexicalThis, true)
+	}
+
 	if node.SubtreeFacts()&(ast.SubtreeContainsAnyAwait|ast.SubtreeContainsAwait) == 0 {
 		return tx.fallbackVisitor(node)
 	}

internal/transformers/estransforms/classfields.go

@@ -1415,6 +1415,7 @@ func (tx *classFieldsTransformer) transformClassStaticBlockDeclaration(node *ast
 		arrowFunction.AsArrowFunction().Body.AsBlock().Statements.Loc = node.AsClassStaticBlockDeclaration().Body.AsBlock().Statements.Loc
 		tx.EmitContext().SetOriginal(iife, node)
 		tx.EmitContext().AssignSourceMapRange(iife, node)
+		tx.EmitContext().AddEmitFlags(arrowFunction, printer.EFNoLexicalThis)
 		return iife
 	}
 	return nil
@@ -2712,6 +2713,9 @@ func (tx *classFieldsTransformer) generateInitializedPropertyExpressionsOrClassS
 func (tx *classFieldsTransformer) transformProperty(property *ast.PropertyDeclaration, receiver *ast.Expression) *ast.Expression {
 	savedCurrentClassElement := tx.currentClassElement
 	transformed := tx.transformPropertyWorker(property, receiver)
+	if transformed != nil && ast.HasStaticModifier(property.AsNode()) {
+		tx.EmitContext().AddEmitFlags(transformed, printer.EFNoLexicalThis)
+	}
 	if transformed != nil && ast.HasStaticModifier(property.AsNode()) &&
 		tx.lexicalEnvironment != nil && tx.lexicalEnvironment.data != nil && tx.lexicalEnvironment.data.facts != 0 {
 		// capture the lexical environment for the member

testdata/baselines/reference/compiler/asyncArrowStaticFieldThis.js

@@ -0,0 +1,32 @@
+//// [tests/cases/compiler/asyncArrowStaticFieldThis.ts] ////
+
+//// [asyncArrowStaticFieldThis.ts]
+namespace NS {
+    export class C {
+        static h = async () => 1;
+        static i = async () => this.h;
+    }
+}
+
+
+//// [asyncArrowStaticFieldThis.js]
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var NS;
+(function (NS) {
+    var _a;
+    class C {
+    }
+    _a = C;
+    C.h = () => __awaiter(void 0, void 0, void 0, function* () { return 1; });
+    C.i = () => __awaiter(void 0, void 0, void 0, function* () { return _a.h; });
+    NS.C = C;
+})(NS || (NS = {}));

testdata/tests/cases/compiler/asyncArrowStaticFieldThis.ts

@@ -0,0 +1,9 @@
+// @target: es2015
+// @noTypesAndSymbols: true
+
+namespace NS {
+    export class C {
+        static h = async () => 1;
+        static i = async () => this.h;
+    }
+}