From 22e3c37d29841efa19982091567bd1106f033a0c Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 2 May 2024 18:21:20 -0400 Subject: [PATCH 1/2] Fix name generation scoping --- src/compiler/emitter.ts | 79 ++++++++++--------- .../unittests/evaluation/asyncArrow.ts | 25 ++++++ .../reference/autoAccessor5(target=es2022).js | 6 +- ...ervation(module=commonjs,target=es2022).js | 6 +- ...eservation(module=esnext,target=es2022).js | 6 +- ...assDeclaration-sourceMap(target=es2022).js | 6 +- ...eclaration-sourceMap(target=es2022).js.map | 4 +- ...ion-sourceMap(target=es2022).sourcemap.txt | 34 ++++---- ...sion-commentPreservation(target=es2022).js | 6 +- ...FieldDestructuredBinding(target=es2015).js | 14 ++-- 10 files changed, 108 insertions(+), 78 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 2b95abb5db68c..d24c88792ea59 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2125,13 +2125,9 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitComputedPropertyName(node: ComputedPropertyName) { - const savedPrivateNameTempFlags = privateNameTempFlags; - const savedReservedMemberNames = reservedPrivateNames; - popPrivateNameGenerationScope(); writePunctuation("["); emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfComputedPropertyName); writePunctuation("]"); - pushPrivateNameGenerationScope(savedPrivateNameTempFlags, savedReservedMemberNames); } // @@ -2351,16 +2347,14 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitTypeLiteral(node: TypeLiteralNode) { - // Type literals don't have private names, but we need to push a new scope so that - // we can step out of it when emitting a computed property. - pushPrivateNameGenerationScope(TempFlags.Auto, /*newReservedMemberNames*/ undefined); + pushNameGenerationScope(node); writePunctuation("{"); const flags = getEmitFlags(node) & EmitFlags.SingleLine ? ListFormat.SingleLineTypeLiteralMembers : ListFormat.MultiLineTypeLiteralMembers; emitList(node, node.members, flags | ListFormat.NoSpaceIfEmpty); writePunctuation("}"); - popPrivateNameGenerationScope(); + popNameGenerationScope(node); } function emitArrayType(node: ArrayTypeNode) { @@ -2569,9 +2563,8 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitObjectLiteralExpression(node: ObjectLiteralExpression) { - // Object literals don't have private names, but we need to push a new scope so that - // we can step out of it when emitting a computed property. - pushPrivateNameGenerationScope(TempFlags.Auto, /*newReservedMemberNames*/ undefined); + pushNameGenerationScope(node); + forEach(node.properties, generateMemberNames); const indentedFlag = getEmitFlags(node) & EmitFlags.Indented; @@ -2587,7 +2580,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri decreaseIndent(); } - popPrivateNameGenerationScope(); + popNameGenerationScope(node); } function emitPropertyAccessExpression(node: PropertyAccessExpression) { @@ -3428,7 +3421,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression) { - pushPrivateNameGenerationScope(TempFlags.Auto, /*newReservedMemberNames*/ undefined); + pushNameGenerationScope(node); forEach(node.members, generateMemberNames); @@ -3456,13 +3449,11 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri decreaseIndent(); } - popPrivateNameGenerationScope(); + popNameGenerationScope(node); } function emitInterfaceDeclaration(node: InterfaceDeclaration) { - // Interfaces don't have private names, but we need to push a new scope so that - // we can step out of it when emitting a computed property. - pushPrivateNameGenerationScope(TempFlags.Auto, /*newReservedMemberNames*/ undefined); + pushNameGenerationScope(node); emitDecoratorsAndModifiers(node, node.modifiers, /*allowDecorators*/ false); writeKeyword("interface"); @@ -3475,7 +3466,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emitList(node, node.members, ListFormat.InterfaceMembers); writePunctuation("}"); - popPrivateNameGenerationScope(); + popNameGenerationScope(node); } function emitTypeAliasDeclaration(node: TypeAliasDeclaration) { @@ -5172,9 +5163,14 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri * Push a new name generation scope. */ function pushNameGenerationScope(node: Node | undefined) { + privateNameTempFlagsStack.push(privateNameTempFlags); + privateNameTempFlags = TempFlags.Auto; + reservedPrivateNamesStack.push(reservedPrivateNames); + if (node && getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) { return; } + tempFlagsStack.push(tempFlags); tempFlags = TempFlags.Auto; formattedNameTempFlagsStack.push(formattedNameTempFlags); @@ -5186,9 +5182,13 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri * Pop the current name generation scope. */ function popNameGenerationScope(node: Node | undefined) { + privateNameTempFlags = privateNameTempFlagsStack.pop()!; + reservedPrivateNames = reservedPrivateNamesStack.pop(); + if (node && getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) { return; } + tempFlags = tempFlagsStack.pop()!; formattedNameTempFlags = formattedNameTempFlagsStack.pop(); reservedNames = reservedNamesStack.pop(); @@ -5201,24 +5201,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri reservedNames.add(name); } - /** - * Push a new member name generation scope. - */ - function pushPrivateNameGenerationScope(newPrivateNameTempFlags: TempFlags, newReservedMemberNames: Set | undefined) { - privateNameTempFlagsStack.push(privateNameTempFlags); - privateNameTempFlags = newPrivateNameTempFlags; - reservedPrivateNamesStack.push(reservedNames); - reservedPrivateNames = newReservedMemberNames; - } - - /** - * Pop the current member name generation scope. - */ - function popPrivateNameGenerationScope() { - privateNameTempFlags = privateNameTempFlagsStack.pop()!; - reservedPrivateNames = reservedPrivateNamesStack.pop(); - } - function reservePrivateNameInNestedScopes(name: string) { if (!reservedPrivateNames || reservedPrivateNames === lastOrUndefined(reservedPrivateNamesStack)) { reservedPrivateNames = new Set(); @@ -5372,7 +5354,30 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function isReservedName(name: string, privateName: boolean): boolean { - return privateName ? !!reservedPrivateNames?.has(name) : !!reservedNames?.has(name); + let set: Set | undefined; + let stack: (Set | undefined)[]; + if (privateName) { + set = reservedPrivateNames; + stack = reservedPrivateNamesStack; + } + else { + set = reservedNames; + stack = reservedNamesStack; + } + + if (set?.has(name)) { + return true; + } + for (let i = stack.length - 1; i >= 0; i--) { + if (set === stack[i]) { + continue; + } + set = stack[i]; + if (set?.has(name)) { + return true; + } + } + return false; } /** diff --git a/src/testRunner/unittests/evaluation/asyncArrow.ts b/src/testRunner/unittests/evaluation/asyncArrow.ts index 6521e89e2befd..87374fdfea3e1 100644 --- a/src/testRunner/unittests/evaluation/asyncArrow.ts +++ b/src/testRunner/unittests/evaluation/asyncArrow.ts @@ -17,4 +17,29 @@ describe("unittests:: evaluation:: asyncArrowEvaluation", () => { await result.main(); assert.instanceOf(result.output[0].a(), result.A); }); + + // https://github.com/microsoft/TypeScript/issues/57897 + it("Class alias (es5)", async () => { + const result = evaluator.evaluateTypeScript(` + class X { + public static a = async (someVar: boolean = true) => { + return await X.b(); + }; + + public static b = async () => { + return "GOOD"; + }; + } + + export async function main() { + try { + return await X.a(); + } + catch (e) { + return "BAD"; + } + }`); + const output = await result.main(); + assert.equal(output, "GOOD"); + }); }); diff --git a/tests/baselines/reference/autoAccessor5(target=es2022).js b/tests/baselines/reference/autoAccessor5(target=es2022).js index 12c663ef4b3d8..ffee7eeaf6a93 100644 --- a/tests/baselines/reference/autoAccessor5(target=es2022).js +++ b/tests/baselines/reference/autoAccessor5(target=es2022).js @@ -30,7 +30,7 @@ class C1 { static set ["z"](value) { C1.#_d_accessor_storage = value; } } class C2 { - #_e_accessor_storage = 1; - get [_a = f()]() { return this.#_e_accessor_storage; } - set [_a](value) { this.#_e_accessor_storage = value; } + #_a_accessor_storage = 1; + get [_a = f()]() { return this.#_a_accessor_storage; } + set [_a](value) { this.#_a_accessor_storage = value; } } diff --git a/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=commonjs,target=es2022).js b/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=commonjs,target=es2022).js index d187a927e2334..a7b585e5678c1 100644 --- a/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=commonjs,target=es2022).js +++ b/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=commonjs,target=es2022).js @@ -189,10 +189,10 @@ let C = (() => { set x(value) { } /*13*/ y = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _y_initializers, 1)); - #z_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); + #z_1_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); /*16*/ - get z() { return this.#z_accessor_storage; } - set z(value) { this.#z_accessor_storage = value; } + get z() { return this.#z_1_accessor_storage; } + set z(value) { this.#z_1_accessor_storage = value; } static { /*28*/ _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) }; diff --git a/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=esnext,target=es2022).js b/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=esnext,target=es2022).js index cbb7239daf266..07a163354c17e 100644 --- a/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=esnext,target=es2022).js +++ b/tests/baselines/reference/esDecorators-classDeclaration-commentPreservation(module=esnext,target=es2022).js @@ -189,10 +189,10 @@ let C = (() => { set x(value) { } /*13*/ y = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _y_initializers, 1)); - #z_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); + #z_1_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); /*16*/ - get z() { return this.#z_accessor_storage; } - set z(value) { this.#z_accessor_storage = value; } + get z() { return this.#z_1_accessor_storage; } + set z(value) { this.#z_1_accessor_storage = value; } static { /*28*/ _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) }; diff --git a/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js b/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js index b2487b3a07105..ab0a43f6b02e1 100644 --- a/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js +++ b/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js @@ -166,9 +166,9 @@ let C = (() => { get x() { return 1; } set x(value) { } y = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _y_initializers, 1)); - #z_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); - get z() { return this.#z_accessor_storage; } - set z(value) { this.#z_accessor_storage = value; } + #z_1_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); + get z() { return this.#z_1_accessor_storage; } + set z(value) { this.#z_1_accessor_storage = value; } static { _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) }; } diff --git a/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js.map b/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js.map index 2db1e0f3b12f3..b8f99545e64c7 100644 --- a/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js.map +++ b/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).js.map @@ -1,6 +1,6 @@ //// [esDecorators-classDeclaration-sourceMap.js.map] -{"version":3,"file":"esDecorators-classDeclaration-sourceMap.js","sourceRoot":"","sources":["esDecorators-classDeclaration-sourceMap.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIM,CAAC;;4BAFN,GAAG,EACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAEC,GAAG,EACH,GAAG;iCAGH,GAAG,EACH,GAAG;iCAGH,GAAG,EACH,GAAG;6BAGH,GAAG,EACH,GAAG;6BAGH,GAAG,EACH,GAAG;iDAGH,GAAG,EACH,GAAG;gDAGH,GAAG,EACH,GAAG;gDAGH,GAAG,EACH,GAAG;4CAGH,GAAG,EACH,GAAG;4CAGH,GAAG,EACH,GAAG;YAfJ,yDAAA,yBAAA,cAAkB,CAAC,YAAA,uSAAA;YAInB,wDAAA,uBAAA,cAAkB,OAAO,CAAC,CAAC,CAAC,CAAC,cAAA,4RAAA;YAI7B,wDAAA,uBAAA,UAAc,KAAa,IAAI,CAAC,cAAA,iTAAA;YAQhC,oDAAA,uBAAA,4FAAuB,cAAA,EAAvB,uBAAA,iGAAuB,cAAA,wZAAA;YApCvB,qKAAA,MAAM,6DAAK;YAIX,0JAAI,CAAC,6DAAgB;YAIrB,qKAAI,CAAC,wEAAmB;YAQxB,wJAAS,CAAC,6BAAD,CAAC,6EAAK;YAgBf,kaAAc;YApBd,qJAAA,CAAC,6BAAD,CAAC,6EAAK;YAfV,6KAwCC;;;;QArCG,MAAM,KAAI,CAAC;QAIX,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;QAIrB,IAAI,CAAC,CAAC,KAAa,IAAI,CAAC;QAIxB,CAAC,IAfC,mDAAC,2CAeC,CAAC,GAAC;QAIN,+GAAa,CAAC,GAAC;QAAf,IAAS,CAAC,uCAAK;QAAf,IAAS,CAAC,6CAAK;;YAgBR,iBAnCL,uDAAC,gEAmCS,CAAC,IAAJ,CAAK;;;YAIE,oKAAK,CAAC,IAAJ,CAAK;;;;;;;YAvCrB,uDAAC"} -//// https://sokra.github.io/source-map-visualization#base64,var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
    var useValue = arguments.length > 2;
    for (var i = 0; i < initializers.length; i++) {
        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
    }
    return useValue ? value : void 0;
};
var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
    var _, done = false;
    for (var i = decorators.length - 1; i >= 0; i--) {
        var context = {};
        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
        if (kind === "accessor") {
            if (result === void 0) continue;
            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
            if (_ = accept(result.get)) descriptor.get = _;
            if (_ = accept(result.set)) descriptor.set = _;
            if (_ = accept(result.init)) initializers.unshift(_);
        }
        else if (_ = accept(result)) {
            if (kind === "field") initializers.unshift(_);
            else descriptor[key] = _;
        }
    }
    if (target) Object.defineProperty(target, contextIn.name, descriptor);
    done = true;
};
var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
    return typeof state === "function" ? receiver === state : state.has(receiver);
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
let C = (() => {
    var _C_method_get, _C_x_get, _C_x_set, _C_y, _C_z_accessor_storage, _C_z_get, _C_z_set;
    let _classDecorators = [dec, dec];
    let _classDescriptor;
    let _classExtraInitializers = [];
    let _classThis;
    let _staticExtraInitializers = [];
    let _instanceExtraInitializers = [];
    let _static_private_method_decorators;
    let _static_private_method_descriptor;
    let _static_private_get_x_decorators;
    let _static_private_get_x_descriptor;
    let _static_private_set_x_decorators;
    let _static_private_set_x_descriptor;
    let _static_private_y_decorators;
    let _static_private_y_initializers = [];
    let _static_private_y_extraInitializers = [];
    let _static_private_z_decorators;
    let _static_private_z_initializers = [];
    let _static_private_z_extraInitializers = [];
    let _static_private_z_descriptor;
    let _method_decorators;
    let _get_x_decorators;
    let _set_x_decorators;
    let _y_decorators;
    let _y_initializers = [];
    let _y_extraInitializers = [];
    let _z_decorators;
    let _z_initializers = [];
    let _z_extraInitializers = [];
    var C = class {
        static { _classThis = this; }
        static { __setFunctionName(this, "C"); }
        static { _C_method_get = function _C_method_get() { return _static_private_method_descriptor.value; }, _C_x_get = function _C_x_get() { return _static_private_get_x_descriptor.get.call(this); }, _C_x_set = function _C_x_set(value) { return _static_private_set_x_descriptor.set.call(this, value); }, _C_z_get = function _C_z_get() { return _static_private_z_descriptor.get.call(this); }, _C_z_set = function _C_z_set(value) { return _static_private_z_descriptor.set.call(this, value); }; }
        static {
            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
            _method_decorators = [dec, dec];
            _get_x_decorators = [dec, dec];
            _set_x_decorators = [dec, dec];
            _y_decorators = [dec, dec];
            _z_decorators = [dec, dec];
            _static_private_method_decorators = [dec, dec];
            _static_private_get_x_decorators = [dec, dec];
            _static_private_set_x_decorators = [dec, dec];
            _static_private_y_decorators = [dec, dec];
            _static_private_z_decorators = [dec, dec];
            __esDecorate(this, _static_private_method_descriptor = { value: __setFunctionName(function () { }, "#method") }, _static_private_method_decorators, { kind: "method", name: "#method", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "a", _C_method_get) }, metadata: _metadata }, null, _staticExtraInitializers);
            __esDecorate(this, _static_private_get_x_descriptor = { get: __setFunctionName(function () { return 1; }, "#x", "get") }, _static_private_get_x_decorators, { kind: "getter", name: "#x", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "a", _C_x_get) }, metadata: _metadata }, null, _staticExtraInitializers);
            __esDecorate(this, _static_private_set_x_descriptor = { set: __setFunctionName(function (value) { }, "#x", "set") }, _static_private_set_x_decorators, { kind: "setter", name: "#x", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), set: (obj, value) => { __classPrivateFieldSet(obj, _classThis, value, "a", _C_x_set); } }, metadata: _metadata }, null, _staticExtraInitializers);
            __esDecorate(this, _static_private_z_descriptor = { get: __setFunctionName(function () { return __classPrivateFieldGet(this, _classThis, "f", _C_z_accessor_storage); }, "#z", "get"), set: __setFunctionName(function (value) { __classPrivateFieldSet(this, _classThis, value, "f", _C_z_accessor_storage); }, "#z", "set") }, _static_private_z_decorators, { kind: "accessor", name: "#z", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "a", _C_z_get), set: (obj, value) => { __classPrivateFieldSet(obj, _classThis, value, "a", _C_z_set); } }, metadata: _metadata }, _static_private_z_initializers, _static_private_z_extraInitializers);
            __esDecorate(this, null, _method_decorators, { kind: "method", name: "method", static: false, private: false, access: { has: obj => "method" in obj, get: obj => obj.method }, metadata: _metadata }, null, _instanceExtraInitializers);
            __esDecorate(this, null, _get_x_decorators, { kind: "getter", name: "x", static: false, private: false, access: { has: obj => "x" in obj, get: obj => obj.x }, metadata: _metadata }, null, _instanceExtraInitializers);
            __esDecorate(this, null, _set_x_decorators, { kind: "setter", name: "x", static: false, private: false, access: { has: obj => "x" in obj, set: (obj, value) => { obj.x = value; } }, metadata: _metadata }, null, _instanceExtraInitializers);
            __esDecorate(this, null, _z_decorators, { kind: "accessor", name: "z", static: false, private: false, access: { has: obj => "z" in obj, get: obj => obj.z, set: (obj, value) => { obj.z = value; } }, metadata: _metadata }, _z_initializers, _z_extraInitializers);
            __esDecorate(null, null, _static_private_y_decorators, { kind: "field", name: "#y", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "f", _C_y), set: (obj, value) => { __classPrivateFieldSet(obj, _classThis, value, "f", _C_y); } }, metadata: _metadata }, _static_private_y_initializers, _static_private_y_extraInitializers);
            __esDecorate(null, null, _y_decorators, { kind: "field", name: "y", static: false, private: false, access: { has: obj => "y" in obj, get: obj => obj.y, set: (obj, value) => { obj.y = value; } }, metadata: _metadata }, _y_initializers, _y_extraInitializers);
            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
            C = _classThis = _classDescriptor.value;
            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
        }
        method() { }
        get x() { return 1; }
        set x(value) { }
        y = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _y_initializers, 1));
        #z_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1));
        get z() { return this.#z_accessor_storage; }
        set z(value) { this.#z_accessor_storage = value; }
        static {
            _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) };
        }
        static {
            _C_z_accessor_storage = { value: (__runInitializers(_classThis, _static_private_y_extraInitializers), __runInitializers(_classThis, _static_private_z_initializers, 1)) };
        }
        constructor() {
            __runInitializers(this, _z_extraInitializers);
        }
        static {
            __runInitializers(_classThis, _static_private_z_extraInitializers);
            __runInitializers(_classThis, _classExtraInitializers);
        }
    };
    return C = _classThis;
})();
//# sourceMappingURL=esDecorators-classDeclaration-sourceMap.js.map,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNEZWNvcmF0b3JzLWNsYXNzRGVjbGFyYXRpb24tc291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZXNEZWNvcmF0b3JzLWNsYXNzRGVjbGFyYXRpb24tc291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0lBSU0sQ0FBQzs7NEJBRk4sR0FBRyxFQUNILEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7a0NBRUMsR0FBRyxFQUNILEdBQUc7aUNBR0gsR0FBRyxFQUNILEdBQUc7aUNBR0gsR0FBRyxFQUNILEdBQUc7NkJBR0gsR0FBRyxFQUNILEdBQUc7NkJBR0gsR0FBRyxFQUNILEdBQUc7aURBR0gsR0FBRyxFQUNILEdBQUc7Z0RBR0gsR0FBRyxFQUNILEdBQUc7Z0RBR0gsR0FBRyxFQUNILEdBQUc7NENBR0gsR0FBRyxFQUNILEdBQUc7NENBR0gsR0FBRyxFQUNILEdBQUc7WUFmSix5REFBQSx5QkFBQSxjQUFrQixDQUFDLFlBQUEsdVNBQUE7WUFJbkIsd0RBQUEsdUJBQUEsY0FBa0IsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLGNBQUEsNFJBQUE7WUFJN0Isd0RBQUEsdUJBQUEsVUFBYyxLQUFhLElBQUksQ0FBQyxjQUFBLGlUQUFBO1lBUWhDLG9EQUFBLHVCQUFBLDRGQUF1QixjQUFBLEVBQXZCLHVCQUFBLGlHQUF1QixjQUFBLHdaQUFBO1lBcEN2QixxS0FBQSxNQUFNLDZEQUFLO1lBSVgsMEpBQUksQ0FBQyw2REFBZ0I7WUFJckIscUtBQUksQ0FBQyx3RUFBbUI7WUFReEIsd0pBQVMsQ0FBQyw2QkFBRCxDQUFDLDZFQUFLO1lBZ0JmLGthQUFjO1lBcEJkLHFKQUFBLENBQUMsNkJBQUQsQ0FBQyw2RUFBSztZQWZWLDZLQXdDQzs7OztRQXJDRyxNQUFNLEtBQUksQ0FBQztRQUlYLElBQUksQ0FBQyxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUlyQixJQUFJLENBQUMsQ0FBQyxLQUFhLElBQUksQ0FBQztRQUl4QixDQUFDLElBZkMsbURBQUMsMkNBZUMsQ0FBQyxHQUFDO1FBSU4sK0dBQWEsQ0FBQyxHQUFDO1FBQWYsSUFBUyxDQUFDLHVDQUFLO1FBQWYsSUFBUyxDQUFDLDZDQUFLOztZQWdCUixpQkFuQ0wsdURBQUMsZ0VBbUNTLENBQUMsSUFBSixDQUFLOzs7WUFJRSxvS0FBSyxDQUFDLElBQUosQ0FBSzs7Ozs7OztZQXZDckIsdURBQUMifQ==,ZGVjbGFyZSB2YXIgZGVjOiBhbnk7CgpAZGVjCkBkZWMKY2xhc3MgQyB7CiAgICBAZGVjCiAgICBAZGVjCiAgICBtZXRob2QoKSB7fQoKICAgIEBkZWMKICAgIEBkZWMKICAgIGdldCB4KCkgeyByZXR1cm4gMTsgfQoKICAgIEBkZWMKICAgIEBkZWMKICAgIHNldCB4KHZhbHVlOiBudW1iZXIpIHsgfQoKICAgIEBkZWMKICAgIEBkZWMKICAgIHkgPSAxOwoKICAgIEBkZWMKICAgIEBkZWMKICAgIGFjY2Vzc29yIHogPSAxOwoKICAgIEBkZWMKICAgIEBkZWMKICAgIHN0YXRpYyAjbWV0aG9kKCkge30KCiAgICBAZGVjCiAgICBAZGVjCiAgICBzdGF0aWMgZ2V0ICN4KCkgeyByZXR1cm4gMTsgfQoKICAgIEBkZWMKICAgIEBkZWMKICAgIHN0YXRpYyBzZXQgI3godmFsdWU6IG51bWJlcikgeyB9CgogICAgQGRlYwogICAgQGRlYwogICAgc3RhdGljICN5ID0gMTsKCiAgICBAZGVjCiAgICBAZGVjCiAgICBzdGF0aWMgYWNjZXNzb3IgI3ogPSAxOwp9Cg== +{"version":3,"file":"esDecorators-classDeclaration-sourceMap.js","sourceRoot":"","sources":["esDecorators-classDeclaration-sourceMap.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIM,CAAC;;4BAFN,GAAG,EACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAEC,GAAG,EACH,GAAG;iCAGH,GAAG,EACH,GAAG;iCAGH,GAAG,EACH,GAAG;6BAGH,GAAG,EACH,GAAG;6BAGH,GAAG,EACH,GAAG;iDAGH,GAAG,EACH,GAAG;gDAGH,GAAG,EACH,GAAG;gDAGH,GAAG,EACH,GAAG;4CAGH,GAAG,EACH,GAAG;4CAGH,GAAG,EACH,GAAG;YAfJ,yDAAA,yBAAA,cAAkB,CAAC,YAAA,uSAAA;YAInB,wDAAA,uBAAA,cAAkB,OAAO,CAAC,CAAC,CAAC,CAAC,cAAA,4RAAA;YAI7B,wDAAA,uBAAA,UAAc,KAAa,IAAI,CAAC,cAAA,iTAAA;YAQhC,oDAAA,uBAAA,4FAAuB,cAAA,EAAvB,uBAAA,iGAAuB,cAAA,wZAAA;YApCvB,qKAAA,MAAM,6DAAK;YAIX,0JAAI,CAAC,6DAAgB;YAIrB,qKAAI,CAAC,wEAAmB;YAQxB,wJAAS,CAAC,6BAAD,CAAC,6EAAK;YAgBf,kaAAc;YApBd,qJAAA,CAAC,6BAAD,CAAC,6EAAK;YAfV,6KAwCC;;;;QArCG,MAAM,KAAI,CAAC;QAIX,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;QAIrB,IAAI,CAAC,CAAC,KAAa,IAAI,CAAC;QAIxB,CAAC,IAfC,mDAAC,2CAeC,CAAC,GAAC;QAIN,iHAAa,CAAC,GAAC;QAAf,IAAS,CAAC,yCAAK;QAAf,IAAS,CAAC,+CAAK;;YAgBR,iBAnCL,uDAAC,gEAmCS,CAAC,IAAJ,CAAK;;;YAIE,oKAAK,CAAC,IAAJ,CAAK;;;;;;;YAvCrB,uDAAC"} +//// https://sokra.github.io/source-map-visualization#base64,var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
    var useValue = arguments.length > 2;
    for (var i = 0; i < initializers.length; i++) {
        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
    }
    return useValue ? value : void 0;
};
var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
    var _, done = false;
    for (var i = decorators.length - 1; i >= 0; i--) {
        var context = {};
        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
        if (kind === "accessor") {
            if (result === void 0) continue;
            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
            if (_ = accept(result.get)) descriptor.get = _;
            if (_ = accept(result.set)) descriptor.set = _;
            if (_ = accept(result.init)) initializers.unshift(_);
        }
        else if (_ = accept(result)) {
            if (kind === "field") initializers.unshift(_);
            else descriptor[key] = _;
        }
    }
    if (target) Object.defineProperty(target, contextIn.name, descriptor);
    done = true;
};
var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
    return typeof state === "function" ? receiver === state : state.has(receiver);
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
let C = (() => {
    var _C_method_get, _C_x_get, _C_x_set, _C_y, _C_z_accessor_storage, _C_z_get, _C_z_set;
    let _classDecorators = [dec, dec];
    let _classDescriptor;
    let _classExtraInitializers = [];
    let _classThis;
    let _staticExtraInitializers = [];
    let _instanceExtraInitializers = [];
    let _static_private_method_decorators;
    let _static_private_method_descriptor;
    let _static_private_get_x_decorators;
    let _static_private_get_x_descriptor;
    let _static_private_set_x_decorators;
    let _static_private_set_x_descriptor;
    let _static_private_y_decorators;
    let _static_private_y_initializers = [];
    let _static_private_y_extraInitializers = [];
    let _static_private_z_decorators;
    let _static_private_z_initializers = [];
    let _static_private_z_extraInitializers = [];
    let _static_private_z_descriptor;
    let _method_decorators;
    let _get_x_decorators;
    let _set_x_decorators;
    let _y_decorators;
    let _y_initializers = [];
    let _y_extraInitializers = [];
    let _z_decorators;
    let _z_initializers = [];
    let _z_extraInitializers = [];
    var C = class {
        static { _classThis = this; }
        static { __setFunctionName(this, "C"); }
        static { _C_method_get = function _C_method_get() { return _static_private_method_descriptor.value; }, _C_x_get = function _C_x_get() { return _static_private_get_x_descriptor.get.call(this); }, _C_x_set = function _C_x_set(value) { return _static_private_set_x_descriptor.set.call(this, value); }, _C_z_get = function _C_z_get() { return _static_private_z_descriptor.get.call(this); }, _C_z_set = function _C_z_set(value) { return _static_private_z_descriptor.set.call(this, value); }; }
        static {
            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
            _method_decorators = [dec, dec];
            _get_x_decorators = [dec, dec];
            _set_x_decorators = [dec, dec];
            _y_decorators = [dec, dec];
            _z_decorators = [dec, dec];
            _static_private_method_decorators = [dec, dec];
            _static_private_get_x_decorators = [dec, dec];
            _static_private_set_x_decorators = [dec, dec];
            _static_private_y_decorators = [dec, dec];
            _static_private_z_decorators = [dec, dec];
            __esDecorate(this, _static_private_method_descriptor = { value: __setFunctionName(function () { }, "#method") }, _static_private_method_decorators, { kind: "method", name: "#method", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "a", _C_method_get) }, metadata: _metadata }, null, _staticExtraInitializers);
            __esDecorate(this, _static_private_get_x_descriptor = { get: __setFunctionName(function () { return 1; }, "#x", "get") }, _static_private_get_x_decorators, { kind: "getter", name: "#x", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "a", _C_x_get) }, metadata: _metadata }, null, _staticExtraInitializers);
            __esDecorate(this, _static_private_set_x_descriptor = { set: __setFunctionName(function (value) { }, "#x", "set") }, _static_private_set_x_decorators, { kind: "setter", name: "#x", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), set: (obj, value) => { __classPrivateFieldSet(obj, _classThis, value, "a", _C_x_set); } }, metadata: _metadata }, null, _staticExtraInitializers);
            __esDecorate(this, _static_private_z_descriptor = { get: __setFunctionName(function () { return __classPrivateFieldGet(this, _classThis, "f", _C_z_accessor_storage); }, "#z", "get"), set: __setFunctionName(function (value) { __classPrivateFieldSet(this, _classThis, value, "f", _C_z_accessor_storage); }, "#z", "set") }, _static_private_z_decorators, { kind: "accessor", name: "#z", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "a", _C_z_get), set: (obj, value) => { __classPrivateFieldSet(obj, _classThis, value, "a", _C_z_set); } }, metadata: _metadata }, _static_private_z_initializers, _static_private_z_extraInitializers);
            __esDecorate(this, null, _method_decorators, { kind: "method", name: "method", static: false, private: false, access: { has: obj => "method" in obj, get: obj => obj.method }, metadata: _metadata }, null, _instanceExtraInitializers);
            __esDecorate(this, null, _get_x_decorators, { kind: "getter", name: "x", static: false, private: false, access: { has: obj => "x" in obj, get: obj => obj.x }, metadata: _metadata }, null, _instanceExtraInitializers);
            __esDecorate(this, null, _set_x_decorators, { kind: "setter", name: "x", static: false, private: false, access: { has: obj => "x" in obj, set: (obj, value) => { obj.x = value; } }, metadata: _metadata }, null, _instanceExtraInitializers);
            __esDecorate(this, null, _z_decorators, { kind: "accessor", name: "z", static: false, private: false, access: { has: obj => "z" in obj, get: obj => obj.z, set: (obj, value) => { obj.z = value; } }, metadata: _metadata }, _z_initializers, _z_extraInitializers);
            __esDecorate(null, null, _static_private_y_decorators, { kind: "field", name: "#y", static: true, private: true, access: { has: obj => __classPrivateFieldIn(_classThis, obj), get: obj => __classPrivateFieldGet(obj, _classThis, "f", _C_y), set: (obj, value) => { __classPrivateFieldSet(obj, _classThis, value, "f", _C_y); } }, metadata: _metadata }, _static_private_y_initializers, _static_private_y_extraInitializers);
            __esDecorate(null, null, _y_decorators, { kind: "field", name: "y", static: false, private: false, access: { has: obj => "y" in obj, get: obj => obj.y, set: (obj, value) => { obj.y = value; } }, metadata: _metadata }, _y_initializers, _y_extraInitializers);
            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
            C = _classThis = _classDescriptor.value;
            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
        }
        method() { }
        get x() { return 1; }
        set x(value) { }
        y = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _y_initializers, 1));
        #z_1_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1));
        get z() { return this.#z_1_accessor_storage; }
        set z(value) { this.#z_1_accessor_storage = value; }
        static {
            _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) };
        }
        static {
            _C_z_accessor_storage = { value: (__runInitializers(_classThis, _static_private_y_extraInitializers), __runInitializers(_classThis, _static_private_z_initializers, 1)) };
        }
        constructor() {
            __runInitializers(this, _z_extraInitializers);
        }
        static {
            __runInitializers(_classThis, _static_private_z_extraInitializers);
            __runInitializers(_classThis, _classExtraInitializers);
        }
    };
    return C = _classThis;
})();
//# sourceMappingURL=esDecorators-classDeclaration-sourceMap.js.map,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNEZWNvcmF0b3JzLWNsYXNzRGVjbGFyYXRpb24tc291cmNlTWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZXNEZWNvcmF0b3JzLWNsYXNzRGVjbGFyYXRpb24tc291cmNlTWFwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0lBSU0sQ0FBQzs7NEJBRk4sR0FBRyxFQUNILEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7a0NBRUMsR0FBRyxFQUNILEdBQUc7aUNBR0gsR0FBRyxFQUNILEdBQUc7aUNBR0gsR0FBRyxFQUNILEdBQUc7NkJBR0gsR0FBRyxFQUNILEdBQUc7NkJBR0gsR0FBRyxFQUNILEdBQUc7aURBR0gsR0FBRyxFQUNILEdBQUc7Z0RBR0gsR0FBRyxFQUNILEdBQUc7Z0RBR0gsR0FBRyxFQUNILEdBQUc7NENBR0gsR0FBRyxFQUNILEdBQUc7NENBR0gsR0FBRyxFQUNILEdBQUc7WUFmSix5REFBQSx5QkFBQSxjQUFrQixDQUFDLFlBQUEsdVNBQUE7WUFJbkIsd0RBQUEsdUJBQUEsY0FBa0IsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLGNBQUEsNFJBQUE7WUFJN0Isd0RBQUEsdUJBQUEsVUFBYyxLQUFhLElBQUksQ0FBQyxjQUFBLGlUQUFBO1lBUWhDLG9EQUFBLHVCQUFBLDRGQUF1QixjQUFBLEVBQXZCLHVCQUFBLGlHQUF1QixjQUFBLHdaQUFBO1lBcEN2QixxS0FBQSxNQUFNLDZEQUFLO1lBSVgsMEpBQUksQ0FBQyw2REFBZ0I7WUFJckIscUtBQUksQ0FBQyx3RUFBbUI7WUFReEIsd0pBQVMsQ0FBQyw2QkFBRCxDQUFDLDZFQUFLO1lBZ0JmLGthQUFjO1lBcEJkLHFKQUFBLENBQUMsNkJBQUQsQ0FBQyw2RUFBSztZQWZWLDZLQXdDQzs7OztRQXJDRyxNQUFNLEtBQUksQ0FBQztRQUlYLElBQUksQ0FBQyxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUlyQixJQUFJLENBQUMsQ0FBQyxLQUFhLElBQUksQ0FBQztRQUl4QixDQUFDLElBZkMsbURBQUMsMkNBZUMsQ0FBQyxHQUFDO1FBSU4saUhBQWEsQ0FBQyxHQUFDO1FBQWYsSUFBUyxDQUFDLHlDQUFLO1FBQWYsSUFBUyxDQUFDLCtDQUFLOztZQWdCUixpQkFuQ0wsdURBQUMsZ0VBbUNTLENBQUMsSUFBSixDQUFLOzs7WUFJRSxvS0FBSyxDQUFDLElBQUosQ0FBSzs7Ozs7OztZQXZDckIsdURBQUMifQ==,ZGVjbGFyZSB2YXIgZGVjOiBhbnk7CgpAZGVjCkBkZWMKY2xhc3MgQyB7CiAgICBAZGVjCiAgICBAZGVjCiAgICBtZXRob2QoKSB7fQoKICAgIEBkZWMKICAgIEBkZWMKICAgIGdldCB4KCkgeyByZXR1cm4gMTsgfQoKICAgIEBkZWMKICAgIEBkZWMKICAgIHNldCB4KHZhbHVlOiBudW1iZXIpIHsgfQoKICAgIEBkZWMKICAgIEBkZWMKICAgIHkgPSAxOwoKICAgIEBkZWMKICAgIEBkZWMKICAgIGFjY2Vzc29yIHogPSAxOwoKICAgIEBkZWMKICAgIEBkZWMKICAgIHN0YXRpYyAjbWV0aG9kKCkge30KCiAgICBAZGVjCiAgICBAZGVjCiAgICBzdGF0aWMgZ2V0ICN4KCkgeyByZXR1cm4gMTsgfQoKICAgIEBkZWMKICAgIEBkZWMKICAgIHN0YXRpYyBzZXQgI3godmFsdWU6IG51bWJlcikgeyB9CgogICAgQGRlYwogICAgQGRlYwogICAgc3RhdGljICN5ID0gMTsKCiAgICBAZGVjCiAgICBAZGVjCiAgICBzdGF0aWMgYWNjZXNzb3IgI3ogPSAxOwp9Cg== //// [esDecorators-classDeclaration-sourceMap.d.ts.map] {"version":3,"file":"esDecorators-classDeclaration-sourceMap.d.ts","sourceRoot":"","sources":["esDecorators-classDeclaration-sourceMap.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,IAAI,GAAG,EAAE,GAAG,CAAC;AAErB,cAEM,CAAC;;IAGH,MAAM;IAEN,IAEI,CAAC,IAIQ,MAAM,CAJE;IAErB,IAEI,CAAC,CAAC,KAAK,EAAE,MAAM,EAAK;IAIxB,CAAC,SAAK;IAIN,QAAQ,CAAC,CAAC,SAAK;CAqBlB"} diff --git a/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).sourcemap.txt b/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).sourcemap.txt index fe77eaedd8bbc..2b89583dd8ff5 100644 --- a/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).sourcemap.txt +++ b/tests/baselines/reference/esDecorators-classDeclaration-sourceMap(target=es2022).sourcemap.txt @@ -707,7 +707,7 @@ sourceFile:esDecorators-classDeclaration-sourceMap.ts 5 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 > ^ 7 > ^^^ -8 > ^^^^^^^^^^^^^-> +8 > ^^^^^^^^^^^^^^^-> 1-> > > @dec @@ -742,30 +742,30 @@ sourceFile:esDecorators-classDeclaration-sourceMap.ts 6 >Emitted(117, 109) Source(20, 10) + SourceIndex(0) 7 >Emitted(117, 112) Source(20, 11) + SourceIndex(0) --- ->>> #z_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); +>>> #z_1_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); 1->^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -3 > ^ -4 > ^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +3 > ^ +4 > ^^^ 1-> > > @dec > @dec > 2 > accessor z = -3 > 1 -4 > ; +3 > 1 +4 > ; 1->Emitted(118, 9) Source(24, 5) + SourceIndex(0) -2 >Emitted(118, 120) Source(24, 18) + SourceIndex(0) -3 >Emitted(118, 121) Source(24, 19) + SourceIndex(0) -4 >Emitted(118, 124) Source(24, 20) + SourceIndex(0) +2 >Emitted(118, 122) Source(24, 18) + SourceIndex(0) +3 >Emitted(118, 123) Source(24, 19) + SourceIndex(0) +4 >Emitted(118, 126) Source(24, 20) + SourceIndex(0) --- ->>> get z() { return this.#z_accessor_storage; } +>>> get z() { return this.#z_1_accessor_storage; } 1 >^^^^^^^^ 2 > ^^^^ 3 > ^ -4 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -5 > ^^^^^^^-> +4 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +5 > ^^^^^^^-> 1 > 2 > accessor 3 > z @@ -773,13 +773,13 @@ sourceFile:esDecorators-classDeclaration-sourceMap.ts 1 >Emitted(119, 9) Source(24, 5) + SourceIndex(0) 2 >Emitted(119, 13) Source(24, 14) + SourceIndex(0) 3 >Emitted(119, 14) Source(24, 15) + SourceIndex(0) -4 >Emitted(119, 53) Source(24, 20) + SourceIndex(0) +4 >Emitted(119, 55) Source(24, 20) + SourceIndex(0) --- ->>> set z(value) { this.#z_accessor_storage = value; } +>>> set z(value) { this.#z_1_accessor_storage = value; } 1->^^^^^^^^ 2 > ^^^^ 3 > ^ -4 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +4 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1-> 2 > accessor 3 > z @@ -787,7 +787,7 @@ sourceFile:esDecorators-classDeclaration-sourceMap.ts 1->Emitted(120, 9) Source(24, 5) + SourceIndex(0) 2 >Emitted(120, 13) Source(24, 14) + SourceIndex(0) 3 >Emitted(120, 14) Source(24, 15) + SourceIndex(0) -4 >Emitted(120, 59) Source(24, 20) + SourceIndex(0) +4 >Emitted(120, 61) Source(24, 20) + SourceIndex(0) --- >>> static { >>> _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) }; diff --git a/tests/baselines/reference/esDecorators-classExpression-commentPreservation(target=es2022).js b/tests/baselines/reference/esDecorators-classExpression-commentPreservation(target=es2022).js index 164f96e3c1c5a..e8a51587b37a5 100644 --- a/tests/baselines/reference/esDecorators-classExpression-commentPreservation(target=es2022).js +++ b/tests/baselines/reference/esDecorators-classExpression-commentPreservation(target=es2022).js @@ -154,10 +154,10 @@ class C { set x(value) { } /*14*/ y = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _y_initializers, 1)); - #z_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); + #z_1_accessor_storage = (__runInitializers(this, _y_extraInitializers), __runInitializers(this, _z_initializers, 1)); /*17*/ - get z() { return this.#z_accessor_storage; } - set z(value) { this.#z_accessor_storage = value; } + get z() { return this.#z_1_accessor_storage; } + set z(value) { this.#z_1_accessor_storage = value; } static { /*29*/ _C_y = { value: (__runInitializers(_classThis, _staticExtraInitializers), __runInitializers(_classThis, _static_private_y_initializers, 1)) }; diff --git a/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2015).js b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2015).js index 089ccdd131e28..ec8500fd4239b 100644 --- a/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2015).js +++ b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2015).js @@ -45,13 +45,13 @@ class A { var _c; this.otherClass = _b; let y; - ({ x: ({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value, y } = this.testObject()); - ([({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value, y] = this.testArray()); - ({ a: ({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value, b: [({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value] } = { a: 1, b: [2] }); - [({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value, [({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value]] = [1, [2]]; - ({ a: ({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value = 1, b: [({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value = 1] } = { b: [] }); - [({ set value(_b) { __classPrivateFieldSet(_b, _b, _b, "f", _A_field); } }).value = 2] = []; - _c = this.otherClass, [({ set value(_b) { __classPrivateFieldSet(_c, _b, _b, "f", _A_field); } }).value = 2] = []; + ({ x: ({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value, y } = this.testObject()); + ([({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value, y] = this.testArray()); + ({ a: ({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value, b: [({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value] } = { a: 1, b: [2] }); + [({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value, [({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value]] = [1, [2]]; + ({ a: ({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value = 1, b: [({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value = 1] } = { b: [] }); + [({ set value(_d) { __classPrivateFieldSet(_b, _b, _d, "f", _A_field); } }).value = 2] = []; + _c = this.otherClass, [({ set value(_d) { __classPrivateFieldSet(_c, _b, _d, "f", _A_field); } }).value = 2] = []; } static test(_a) { [({ set value(_c) { __classPrivateFieldSet(_a, _b, _c, "f", _A_field); } }).value] = [2]; From 74bf8b1686d3124e51a7066944080e29ebc8b35c Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Thu, 2 May 2024 19:07:51 -0400 Subject: [PATCH 2/2] Make name generation consistent in signatures and function-likes --- src/compiler/emitter.ts | 137 +++++++++--------- ...ationParameterEvaluation(target=es2015).js | 18 +-- 2 files changed, 75 insertions(+), 80 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index d24c88792ea59..5cec2d2f31411 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2194,15 +2194,10 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitMethodSignature(node: MethodSignature) { - pushNameGenerationScope(node); emitModifierList(node, node.modifiers); emit(node.name); emit(node.questionToken); - emitTypeParameters(node, node.typeParameters); - emitParameters(node, node.parameters); - emitTypeAnnotation(node.type); - writeTrailingSemicolon(); - popNameGenerationScope(node); + emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody); } function emitMethodDeclaration(node: MethodDeclaration) { @@ -2210,18 +2205,20 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emit(node.asteriskToken); emit(node.name); emit(node.questionToken); - emitSignatureAndBody(node, emitSignatureHead); + emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody); } function emitClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration) { writeKeyword("static"); + pushNameGenerationScope(node); emitBlockFunctionBody(node.body); + popNameGenerationScope(node); } function emitConstructor(node: ConstructorDeclaration) { emitDecoratorsAndModifiers(node, node.modifiers, /*allowDecorators*/ false); writeKeyword("constructor"); - emitSignatureAndBody(node, emitSignatureHead); + emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody); } function emitAccessorDeclaration(node: AccessorDeclaration) { @@ -2230,27 +2227,17 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emitTokenWithComment(token, pos, writeKeyword, node); writeSpace(); emit(node.name); - emitSignatureAndBody(node, emitSignatureHead); + emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody); } function emitCallSignature(node: CallSignatureDeclaration) { - pushNameGenerationScope(node); - emitTypeParameters(node, node.typeParameters); - emitParameters(node, node.parameters); - emitTypeAnnotation(node.type); - writeTrailingSemicolon(); - popNameGenerationScope(node); + emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody); } function emitConstructSignature(node: ConstructSignatureDeclaration) { - pushNameGenerationScope(node); writeKeyword("new"); writeSpace(); - emitTypeParameters(node, node.typeParameters); - emitParameters(node, node.parameters); - emitTypeAnnotation(node.type); - writeTrailingSemicolon(); - popNameGenerationScope(node); + emitSignatureAndBody(node, emitSignatureHead, emitEmptyFunctionBody); } function emitIndexSignature(node: IndexSignatureDeclaration) { @@ -2293,14 +2280,19 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitFunctionType(node: FunctionTypeNode) { - pushNameGenerationScope(node); + emitSignatureAndBody(node, emitFunctionTypeHead, emitFunctionTypeBody); + } + + function emitFunctionTypeHead(node: FunctionTypeNode | ConstructorTypeNode) { emitTypeParameters(node, node.typeParameters); emitParametersForArrow(node, node.parameters); writeSpace(); writePunctuation("=>"); + } + + function emitFunctionTypeBody(node: FunctionTypeNode | ConstructorTypeNode) { writeSpace(); emit(node.type); - popNameGenerationScope(node); } function emitJSDocFunctionType(node: JSDocFunctionType) { @@ -2326,17 +2318,10 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitConstructorType(node: ConstructorTypeNode) { - pushNameGenerationScope(node); emitModifierList(node, node.modifiers); writeKeyword("new"); writeSpace(); - emitTypeParameters(node, node.typeParameters); - emitParameters(node, node.parameters); - writeSpace(); - writePunctuation("=>"); - writeSpace(); - emit(node.type); - popNameGenerationScope(node); + emitSignatureAndBody(node, emitFunctionTypeHead, emitFunctionTypeBody); } function emitTypeQuery(node: TypeQueryNode) { @@ -2348,6 +2333,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri function emitTypeLiteral(node: TypeLiteralNode) { pushNameGenerationScope(node); + forEach(node.members, generateMemberNames); writePunctuation("{"); const flags = getEmitFlags(node) & EmitFlags.SingleLine ? ListFormat.SingleLineTypeLiteralMembers : ListFormat.MultiLineTypeLiteralMembers; @@ -2564,7 +2550,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri function emitObjectLiteralExpression(node: ObjectLiteralExpression) { pushNameGenerationScope(node); - forEach(node.properties, generateMemberNames); const indentedFlag = getEmitFlags(node) & EmitFlags.Indented; @@ -2707,7 +2692,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri function emitArrowFunction(node: ArrowFunction) { emitModifierList(node, node.modifiers); - emitSignatureAndBody(node, emitArrowFunctionHead); + emitSignatureAndBody(node, emitArrowFunctionHead, emitArrowFunctionBody); } function emitArrowFunctionHead(node: ArrowFunction) { @@ -2718,6 +2703,16 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emit(node.equalsGreaterThanToken); } + function emitArrowFunctionBody(node: ArrowFunction) { + if (isBlock(node.body)) { + emitBlockFunctionBody(node.body); + } + else { + writeSpace(); + emitExpression(node.body, parenthesizer.parenthesizeConciseBodyOfArrowFunction); + } + } + function emitDeleteExpression(node: DeleteExpression) { emitTokenWithComment(SyntaxKind.DeleteKeyword, node.pos, writeKeyword, node); writeSpace(); @@ -3298,42 +3293,40 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emit(node.asteriskToken); writeSpace(); emitIdentifierName(node.name); - emitSignatureAndBody(node, emitSignatureHead); + emitSignatureAndBody(node, emitSignatureHead, emitFunctionBody); } - function emitSignatureAndBody(node: T, emitSignatureHead: (node: T) => void) { - const body = node.body; - if (body) { - if (isBlock(body)) { - const indentedFlag = getEmitFlags(node) & EmitFlags.Indented; - if (indentedFlag) { - increaseIndent(); - } + function emitSignatureAndBody(node: T, emitSignatureHead: (node: T) => void, emitBody: (node: T) => void) { + const indentedFlag = getEmitFlags(node) & EmitFlags.Indented; + if (indentedFlag) { + increaseIndent(); + } - pushNameGenerationScope(node); - forEach(node.parameters, generateNames); - generateNames(node.body); + pushNameGenerationScope(node); + forEach(node.parameters, generateNames); + emitSignatureHead(node); + emitBody(node); + popNameGenerationScope(node); - emitSignatureHead(node); - emitBlockFunctionBody(body); - popNameGenerationScope(node); + if (indentedFlag) { + decreaseIndent(); + } + } - if (indentedFlag) { - decreaseIndent(); - } - } - else { - emitSignatureHead(node); - writeSpace(); - emitExpression(body, parenthesizer.parenthesizeConciseBodyOfArrowFunction); - } + function emitFunctionBody>(node: T) { + const body = node.body; + if (body) { + emitBlockFunctionBody(body); } else { - emitSignatureHead(node); writeTrailingSemicolon(); } } + function emitEmptyFunctionBody(_node: SignatureDeclaration) { + writeTrailingSemicolon(); + } + function emitSignatureHead(node: SignatureDeclaration) { emitTypeParameters(node, node.typeParameters); emitParameters(node, node.parameters); @@ -3381,6 +3374,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitBlockFunctionBody(body: Block) { + generateNames(body); onBeforeEmitNode?.(body); writeSpace(); writePunctuation("{"); @@ -3421,10 +3415,6 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri } function emitClassDeclarationOrExpression(node: ClassDeclaration | ClassExpression) { - pushNameGenerationScope(node); - - forEach(node.members, generateMemberNames); - emitDecoratorsAndModifiers(node, node.modifiers, /*allowDecorators*/ true); emitTokenWithComment(SyntaxKind.ClassKeyword, moveRangePastModifiers(node).pos, writeKeyword, node); if (node.name) { @@ -3439,22 +3429,22 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emitTypeParameters(node, node.typeParameters); emitList(node, node.heritageClauses, ListFormat.ClassHeritageClauses); - writeSpace(); writePunctuation("{"); + + pushNameGenerationScope(node); + forEach(node.members, generateMemberNames); emitList(node, node.members, ListFormat.ClassMembers); + popNameGenerationScope(node); + writePunctuation("}"); if (indentedFlag) { decreaseIndent(); } - - popNameGenerationScope(node); } function emitInterfaceDeclaration(node: InterfaceDeclaration) { - pushNameGenerationScope(node); - emitDecoratorsAndModifiers(node, node.modifiers, /*allowDecorators*/ false); writeKeyword("interface"); writeSpace(); @@ -3463,10 +3453,13 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emitList(node, node.heritageClauses, ListFormat.HeritageClauses); writeSpace(); writePunctuation("{"); - emitList(node, node.members, ListFormat.InterfaceMembers); - writePunctuation("}"); + pushNameGenerationScope(node); + forEach(node.members, generateMemberNames); + emitList(node, node.members, ListFormat.InterfaceMembers); popNameGenerationScope(node); + + writePunctuation("}"); } function emitTypeAliasDeclaration(node: TypeAliasDeclaration) { @@ -4479,7 +4472,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri emitList(parentNode, parameters, ListFormat.Parameters); } - function canEmitSimpleArrowHead(parentNode: FunctionTypeNode | ArrowFunction, parameters: NodeArray) { + function canEmitSimpleArrowHead(parentNode: FunctionTypeNode | ConstructorTypeNode | ArrowFunction, parameters: NodeArray) { const parameter = singleOrUndefined(parameters); return parameter && parameter.pos === parentNode.pos // may not have parsed tokens between parent and parameter @@ -4495,7 +4488,7 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri && isIdentifier(parameter.name); // parameter name must be identifier } - function emitParametersForArrow(parentNode: FunctionTypeNode | ArrowFunction, parameters: NodeArray) { + function emitParametersForArrow(parentNode: FunctionTypeNode | ConstructorTypeNode | ArrowFunction, parameters: NodeArray) { if (canEmitSimpleArrowHead(parentNode, parameters)) { emitList(parentNode, parameters, ListFormat.Parameters & ~ListFormat.Parenthesis); } @@ -5300,7 +5293,9 @@ export function createPrinter(printerOptions: PrinterOptions = {}, handlers: Pri case SyntaxKind.PropertyAssignment: case SyntaxKind.ShorthandPropertyAssignment: case SyntaxKind.PropertyDeclaration: + case SyntaxKind.PropertySignature: case SyntaxKind.MethodDeclaration: + case SyntaxKind.MethodSignature: case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: generateNameIfNeeded((node as NamedDeclaration).name); diff --git a/tests/baselines/reference/asyncFunctionDeclarationParameterEvaluation(target=es2015).js b/tests/baselines/reference/asyncFunctionDeclarationParameterEvaluation(target=es2015).js index e9282352c199b..8b3f87a20b063 100644 --- a/tests/baselines/reference/asyncFunctionDeclarationParameterEvaluation(target=es2015).js +++ b/tests/baselines/reference/asyncFunctionDeclarationParameterEvaluation(target=es2015).js @@ -79,17 +79,17 @@ function f12() { return (...args_1) => { function f() { const a1 = (x_1, ...args_1) => __awaiter(this, [x_1, ...args_1], void 0, function* (x, y = z) { }); const a2 = (_a) => __awaiter(this, [_a], void 0, function* ({ [z]: x }) { }); - const a3 = (...args_2) => { + const a3 = (...args_1) => { var arguments_10 = arguments; - return __awaiter(this, [...args_2], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); + return __awaiter(this, [...args_1], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }; - const a4 = (...args_2) => __awaiter(this, [...args_2], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }); - const a5 = (...args_3) => __awaiter(this, [...args_3], void 0, function* (x = z, ...args) { }); - const a6 = (...args_4) => __awaiter(this, [...args_4], void 0, function* (x = z, ...args) { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); - const a7 = (...args_5) => __awaiter(this, [...args_5], void 0, function* (x = z, ...args) { return () => __awaiter(this, void 0, void 0, function* () { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }); - const a8 = () => __awaiter(this, void 0, void 0, function* () { return (...args_6) => __awaiter(this, [...args_6], void 0, function* (x = z) { return arguments_10; }); }); - const a9 = () => __awaiter(this, void 0, void 0, function* () { return (...args_7) => __awaiter(this, [...args_7], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }); - const a10 = (...args_8) => __awaiter(this, [...args_8], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return function () { + const a4 = (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }); + const a5 = (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z, ...args) { }); + const a6 = (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z, ...args) { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); + const a7 = (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z, ...args) { return () => __awaiter(this, void 0, void 0, function* () { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }); + const a8 = () => __awaiter(this, void 0, void 0, function* () { return (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z) { return arguments_10; }); }); + const a9 = () => __awaiter(this, void 0, void 0, function* () { return (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return arguments_10; }); }); }); + const a10 = (...args_1) => __awaiter(this, [...args_1], void 0, function* (x = z) { return () => __awaiter(this, void 0, void 0, function* () { return function () { var arguments_11 = arguments; return __awaiter(this, void 0, void 0, function* () { return () => __awaiter(this, void 0, void 0, function* () { return arguments_11; }); }); }; }); });