From 06823fbf1c2e763a5bf76c3990ca98fbbcd98691 Mon Sep 17 00:00:00 2001 From: littleblack111 Date: Tue, 14 May 2024 14:05:49 +0800 Subject: updated node_modules --- .../lib/fields.js | 418 +++++++++++++++------ 1 file changed, 305 insertions(+), 113 deletions(-) (limited to 'node_modules/@babel/helper-create-class-features-plugin/lib/fields.js') diff --git a/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js b/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js index 981cf0b3..66022633 100644 --- a/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js +++ b/node_modules/@babel/helper-create-class-features-plugin/lib/fields.js @@ -7,6 +7,7 @@ exports.buildCheckInRHS = buildCheckInRHS; exports.buildFieldsInitNodes = buildFieldsInitNodes; exports.buildPrivateNamesMap = buildPrivateNamesMap; exports.buildPrivateNamesNodes = buildPrivateNamesNodes; +exports.privateNameVisitorFactory = privateNameVisitorFactory; exports.transformPrivateNamesUsage = transformPrivateNamesUsage; var _core = require("@babel/core"); var _helperReplaceSupers = require("@babel/helper-replace-supers"); @@ -16,23 +17,70 @@ var _helperOptimiseCallExpression = require("@babel/helper-optimise-call-express var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure"); var _helperSkipTransparentExpressionWrappers = require("@babel/helper-skip-transparent-expression-wrappers"); var ts = require("./typescript.js"); -function buildPrivateNamesMap(props) { +{ + var newHelpers = file => { + ; + return file.availableHelper("classPrivateFieldGet2"); + }; +} +function buildPrivateNamesMap(className, privateFieldsAsSymbolsOrProperties, props, file) { const privateNamesMap = new Map(); + let classBrandId; for (const prop of props) { if (prop.isPrivate()) { const { name } = prop.node.key.id; - const update = privateNamesMap.has(name) ? privateNamesMap.get(name) : { - id: prop.scope.generateUidIdentifier(name), - static: prop.node.static, - method: !prop.isProperty() - }; + let update = privateNamesMap.get(name); + if (!update) { + const isMethod = !prop.isProperty(); + const isStatic = prop.node.static; + let initAdded = false; + let id; + if (!privateFieldsAsSymbolsOrProperties && newHelpers(file) && isMethod && !isStatic) { + var _classBrandId; + initAdded = !!classBrandId; + (_classBrandId = classBrandId) != null ? _classBrandId : classBrandId = prop.scope.generateUidIdentifier(`${className}_brand`); + id = classBrandId; + } else { + id = prop.scope.generateUidIdentifier(name); + } + update = { + id, + static: isStatic, + method: isMethod, + initAdded + }; + privateNamesMap.set(name, update); + } if (prop.isClassPrivateMethod()) { if (prop.node.kind === "get") { - update.getId = prop.scope.generateUidIdentifier(`get_${name}`); + const { + body + } = prop.node.body; + let $; + if (body.length === 1 && _core.types.isReturnStatement($ = body[0]) && _core.types.isCallExpression($ = $.argument) && $.arguments.length === 1 && _core.types.isThisExpression($.arguments[0]) && _core.types.isIdentifier($ = $.callee)) { + update.getId = _core.types.cloneNode($); + update.getterDeclared = true; + } else { + update.getId = prop.scope.generateUidIdentifier(`get_${name}`); + } } else if (prop.node.kind === "set") { - update.setId = prop.scope.generateUidIdentifier(`set_${name}`); + const { + params + } = prop.node; + const { + body + } = prop.node.body; + let $; + if (body.length === 1 && _core.types.isExpressionStatement($ = body[0]) && _core.types.isCallExpression($ = $.expression) && $.arguments.length === 2 && _core.types.isThisExpression($.arguments[0]) && _core.types.isIdentifier($.arguments[1], { + name: params[0].name + }) && _core.types.isIdentifier($ = $.callee)) { + update.setId = _core.types.cloneNode($); + update.setterDeclared = true; + } else { + update.setId = prop.scope.generateUidIdentifier(`set_${name}`); + } } else if (prop.node.kind === "method") { update.methodId = prop.scope.generateUidIdentifier(name); } @@ -44,6 +92,7 @@ function buildPrivateNamesMap(props) { } function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, privateFieldsAsSymbols, state) { const initNodes = []; + const injectedIds = new Set(); for (const [name, value] of privateNamesMap) { const { static: isStatic, @@ -51,7 +100,7 @@ function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, priv getId, setId } = value; - const isAccessor = getId || setId; + const isGetterOrSetter = getId || setId; const id = _core.types.cloneNode(value.id); let init; if (privateFieldsAsProperties) { @@ -59,10 +108,14 @@ function buildPrivateNamesNodes(privateNamesMap, privateFieldsAsProperties, priv } else if (privateFieldsAsSymbols) { init = _core.types.callExpression(_core.types.identifier("Symbol"), [_core.types.stringLiteral(name)]); } else if (!isStatic) { - init = _core.types.newExpression(_core.types.identifier(!isMethod || isAccessor ? "WeakMap" : "WeakSet"), []); + if (injectedIds.has(id.name)) continue; + injectedIds.add(id.name); + init = _core.types.newExpression(_core.types.identifier(isMethod && (!isGetterOrSetter || newHelpers(state)) ? "WeakSet" : "WeakMap"), []); } if (init) { - (0, _helperAnnotateAsPure.default)(init); + if (!privateFieldsAsSymbols) { + (0, _helperAnnotateAsPure.default)(init); + } initNodes.push(_core.template.statement.ast`var ${id} = ${init}`); } } @@ -180,6 +233,20 @@ const privateInVisitor = privateNameVisitorFactory({ path.replaceWith(_core.template.expression.ast`${_core.types.cloneNode(id)}.has(${buildCheckInRHS(right, file)})`); } }); +function readOnlyError(file, name) { + return _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name}`)]); +} +function writeOnlyError(file, name) { + if (!file.availableHelper("writeOnlyError")) { + console.warn(`@babel/helpers is outdated, update it to silence this warning.`); + return _core.types.buildUndefinedNode(); + } + return _core.types.callExpression(file.addHelper("writeOnlyError"), [_core.types.stringLiteral(`#${name}`)]); +} +function buildStaticPrivateFieldAccess(expr, noUninitializedPrivateFieldAccess) { + if (noUninitializedPrivateFieldAccess) return expr; + return _core.types.memberExpression(expr, _core.types.identifier("_")); +} const privateNameHandlerSpec = { memoise(member, count) { const { @@ -208,7 +275,8 @@ const privateNameHandlerSpec = { classRef, privateNamesMap, file, - innerBinding + innerBinding, + noUninitializedPrivateFieldAccess } = this; const { name @@ -221,23 +289,52 @@ const privateNameHandlerSpec = { getId, setId } = privateNamesMap.get(name); - const isAccessor = getId || setId; + const isGetterOrSetter = getId || setId; if (isStatic) { - const helperName = isMethod && !isAccessor ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet"; unshadow(classRef.name, member.scope, innerBinding); - return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]); + if (!newHelpers(file)) { + const helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodGet" : "classStaticPrivateFieldSpecGet"; + return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]); + } + const receiver = this.receiver(member); + const skipCheck = _core.types.isIdentifier(receiver) && receiver.name === classRef.name; + if (!isMethod) { + if (skipCheck) { + return buildStaticPrivateFieldAccess(_core.types.cloneNode(id), noUninitializedPrivateFieldAccess); + } + return buildStaticPrivateFieldAccess(_core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, _core.types.cloneNode(id)]), noUninitializedPrivateFieldAccess); + } + if (getId) { + if (skipCheck) { + return _core.types.callExpression(_core.types.cloneNode(getId), [receiver]); + } + return _core.types.callExpression(file.addHelper("classPrivateGetter"), [_core.types.cloneNode(classRef), receiver, _core.types.cloneNode(getId)]); + } + if (setId) { + const err = _core.types.buildUndefinedNode(); + if (skipCheck) return err; + return _core.types.sequenceExpression([_core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver]), err]); + } + if (skipCheck) return _core.types.cloneNode(id); + return _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, _core.types.cloneNode(id)]); } if (isMethod) { - if (isAccessor) { - if (!getId && setId) { - if (file.availableHelper("writeOnlyError")) { - return _core.types.sequenceExpression([this.receiver(member), _core.types.callExpression(file.addHelper("writeOnlyError"), [_core.types.stringLiteral(`#${name}`)])]); - } - console.warn(`@babel/helpers is outdated, update it to silence this warning.`); + if (isGetterOrSetter) { + if (!getId) { + return _core.types.sequenceExpression([this.receiver(member), writeOnlyError(file, name)]); } - return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]); + if (!newHelpers(file)) { + return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]); + } + return _core.types.callExpression(file.addHelper("classPrivateGetter"), [_core.types.cloneNode(id), this.receiver(member), _core.types.cloneNode(getId)]); + } + if (!newHelpers(file)) { + return _core.types.callExpression(file.addHelper("classPrivateMethodGet"), [this.receiver(member), _core.types.cloneNode(id), _core.types.cloneNode(methodId)]); } - return _core.types.callExpression(file.addHelper("classPrivateMethodGet"), [this.receiver(member), _core.types.cloneNode(id), _core.types.cloneNode(methodId)]); + return _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(id), this.receiver(member), _core.types.cloneNode(methodId)]); + } + if (newHelpers(file)) { + return _core.types.callExpression(file.addHelper("classPrivateFieldGet2"), [_core.types.cloneNode(id), this.receiver(member)]); } return _core.types.callExpression(file.addHelper("classPrivateFieldGet"), [this.receiver(member), _core.types.cloneNode(id)]); }, @@ -249,7 +346,8 @@ const privateNameHandlerSpec = { const { classRef, privateNamesMap, - file + file, + noUninitializedPrivateFieldAccess } = this; const { name @@ -261,16 +359,38 @@ const privateNameHandlerSpec = { setId, getId } = privateNamesMap.get(name); - const isAccessor = getId || setId; + const isGetterOrSetter = getId || setId; if (isStatic) { - const helperName = isMethod && !isAccessor ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet"; - return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id), value]); + if (!newHelpers(file)) { + const helperName = isMethod && !isGetterOrSetter ? "classStaticPrivateMethodSet" : "classStaticPrivateFieldSpecSet"; + return _core.types.callExpression(file.addHelper(helperName), [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id), value]); + } + const receiver = this.receiver(member); + const skipCheck = _core.types.isIdentifier(receiver) && receiver.name === classRef.name; + if (isMethod && !setId) { + const err = readOnlyError(file, name); + if (skipCheck) return _core.types.sequenceExpression([value, err]); + return _core.types.sequenceExpression([value, _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver]), readOnlyError(file, name)]); + } + if (setId) { + if (skipCheck) { + return _core.types.callExpression(_core.types.cloneNode(setId), [receiver, value]); + } + return _core.types.callExpression(file.addHelper("classPrivateSetter"), [_core.types.cloneNode(classRef), _core.types.cloneNode(setId), receiver, value]); + } + return _core.types.assignmentExpression("=", buildStaticPrivateFieldAccess(_core.types.cloneNode(id), noUninitializedPrivateFieldAccess), skipCheck ? value : _core.types.callExpression(file.addHelper("assertClassBrand"), [_core.types.cloneNode(classRef), receiver, value])); } if (isMethod) { if (setId) { - return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]); + if (!newHelpers(file)) { + return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]); + } + return _core.types.callExpression(file.addHelper("classPrivateSetter"), [_core.types.cloneNode(id), _core.types.cloneNode(setId), this.receiver(member), value]); } - return _core.types.sequenceExpression([this.receiver(member), value, _core.types.callExpression(file.addHelper("readOnlyError"), [_core.types.stringLiteral(`#${name}`)])]); + return _core.types.sequenceExpression([this.receiver(member), value, readOnlyError(file, name)]); + } + if (newHelpers(file)) { + return _core.types.callExpression(file.addHelper("classPrivateFieldSet2"), [_core.types.cloneNode(id), this.receiver(member), value]); } return _core.types.callExpression(file.addHelper("classPrivateFieldSet"), [this.receiver(member), _core.types.cloneNode(id), value]); }, @@ -278,24 +398,56 @@ const privateNameHandlerSpec = { const { classRef, privateNamesMap, - file + file, + noUninitializedPrivateFieldAccess } = this; const { name } = member.node.property.id; const { id, - static: isStatic + static: isStatic, + method: isMethod, + setId } = privateNamesMap.get(name); - if (isStatic) { - try { - var helper = file.addHelper("classStaticPrivateFieldDestructureSet"); - } catch (_unused) { - throw new Error("Babel can not transpile `[C.#p] = [0]` with @babel/helpers < 7.13.10, \n" + "please update @babel/helpers to the latest version."); + if (!newHelpers(file)) { + if (isStatic) { + try { + var helper = file.addHelper("classStaticPrivateFieldDestructureSet"); + } catch (_unused) { + throw new Error("Babel can not transpile `[C.#p] = [0]` with @babel/helpers < 7.13.10, \n" + "please update @babel/helpers to the latest version."); + } + return _core.types.memberExpression(_core.types.callExpression(helper, [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]), _core.types.identifier("value")); + } + return _core.types.memberExpression(_core.types.callExpression(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), _core.types.cloneNode(id)]), _core.types.identifier("value")); + } + if (isMethod && !setId) { + return _core.types.memberExpression(_core.types.sequenceExpression([member.node.object, readOnlyError(file, name)]), _core.types.identifier("_")); + } + if (isStatic && !isMethod) { + const getCall = this.get(member); + if (!noUninitializedPrivateFieldAccess || !_core.types.isCallExpression(getCall)) { + return getCall; } - return _core.types.memberExpression(_core.types.callExpression(helper, [this.receiver(member), _core.types.cloneNode(classRef), _core.types.cloneNode(id)]), _core.types.identifier("value")); + const ref = getCall.arguments.pop(); + getCall.arguments.push(_core.template.expression.ast`(_) => ${ref} = _`); + return _core.types.memberExpression(_core.types.callExpression(file.addHelper("toSetter"), [getCall]), _core.types.identifier("_")); + } + const setCall = this.set(member, _core.types.identifier("_")); + if (!_core.types.isCallExpression(setCall) || !_core.types.isIdentifier(setCall.arguments[setCall.arguments.length - 1], { + name: "_" + })) { + throw member.buildCodeFrameError("Internal Babel error while compiling this code. This is a Babel bug. " + "Please report it at https://github.com/babel/babel/issues."); } - return _core.types.memberExpression(_core.types.callExpression(file.addHelper("classPrivateFieldDestructureSet"), [this.receiver(member), _core.types.cloneNode(id)]), _core.types.identifier("value")); + let args; + if (_core.types.isMemberExpression(setCall.callee, { + computed: false + }) && _core.types.isIdentifier(setCall.callee.property) && setCall.callee.property.name === "call") { + args = [setCall.callee.object, _core.types.arrayExpression(setCall.arguments.slice(1, -1)), setCall.arguments[0]]; + } else { + args = [setCall.callee, _core.types.arrayExpression(setCall.arguments.slice(0, -1))]; + } + return _core.types.memberExpression(_core.types.callExpression(file.addHelper("toSetter"), args), _core.types.identifier("_")); }, call(member, args) { this.memoise(member, 1); @@ -351,6 +503,7 @@ const privateNameHandlerLoose = { }; function transformPrivateNamesUsage(ref, path, privateNamesMap, { privateFieldsAsProperties, + noUninitializedPrivateFieldAccess, noDocumentAll, innerBinding }, state) { @@ -363,6 +516,7 @@ function transformPrivateNamesUsage(ref, path, privateNamesMap, { file: state }, handler, { noDocumentAll, + noUninitializedPrivateFieldAccess, innerBinding })); body.traverse(privateInVisitor, { @@ -403,48 +557,50 @@ function buildPrivateInstanceFieldInitSpec(ref, prop, privateNamesMap, state) { } } const helper = state.addHelper("classPrivateFieldInitSpec"); - return inheritPropComments(_core.template.statement.ast`${helper}( - ${_core.types.thisExpression()}, - ${_core.types.cloneNode(id)}, - { - writable: true, - value: ${value} - }, - )`, prop); + return inheritPropComments(_core.types.expressionStatement(_core.types.callExpression(helper, [_core.types.thisExpression(), _core.types.cloneNode(id), newHelpers(state) ? value : _core.template.expression.ast`{ writable: true, value: ${value} }`])), prop); } -function buildPrivateStaticFieldInitSpec(prop, privateNamesMap) { +function buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess) { const privateName = privateNamesMap.get(prop.node.key.id.name); - const { - id, - getId, - setId, - initAdded - } = privateName; - const isAccessor = getId || setId; - if (!prop.isProperty() && (initAdded || !isAccessor)) return; - if (isAccessor) { - privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { - initAdded: true - })); + const value = noUninitializedPrivateFieldAccess ? prop.node.value : _core.template.expression.ast`{ + _: ${prop.node.value || _core.types.buildUndefinedNode()} + }`; + return inheritPropComments(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.cloneNode(privateName.id), value)]), prop); +} +{ + var buildPrivateStaticFieldInitSpecOld = function (prop, privateNamesMap) { + const privateName = privateNamesMap.get(prop.node.key.id.name); + const { + id, + getId, + setId, + initAdded + } = privateName; + const isGetterOrSetter = getId || setId; + if (!prop.isProperty() && (initAdded || !isGetterOrSetter)) return; + if (isGetterOrSetter) { + privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { + initAdded: true + })); + return inheritPropComments(_core.template.statement.ast` + var ${_core.types.cloneNode(id)} = { + // configurable is false by default + // enumerable is false by default + // writable is false by default + get: ${getId ? getId.name : prop.scope.buildUndefinedNode()}, + set: ${setId ? setId.name : prop.scope.buildUndefinedNode()} + } + `, prop); + } + const value = prop.node.value || prop.scope.buildUndefinedNode(); return inheritPropComments(_core.template.statement.ast` var ${_core.types.cloneNode(id)} = { // configurable is false by default // enumerable is false by default - // writable is false by default - get: ${getId ? getId.name : prop.scope.buildUndefinedNode()}, - set: ${setId ? setId.name : prop.scope.buildUndefinedNode()} - } + writable: true, + value: ${value} + }; `, prop); - } - const value = prop.node.value || prop.scope.buildUndefinedNode(); - return inheritPropComments(_core.template.statement.ast` - var ${_core.types.cloneNode(id)} = { - // configurable is false by default - // enumerable is false by default - writable: true, - value: ${value} - }; - `, prop); + }; } function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) { const privateName = privateNamesMap.get(prop.node.key.id.name); @@ -466,8 +622,8 @@ function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) { }); `, prop); } - const isAccessor = getId || setId; - if (isAccessor) { + const isGetterOrSetter = getId || setId; + if (isGetterOrSetter) { privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { initAdded: true })); @@ -484,15 +640,12 @@ function buildPrivateMethodInitLoose(ref, prop, privateNamesMap) { } function buildPrivateInstanceMethodInitSpec(ref, prop, privateNamesMap, state) { const privateName = privateNamesMap.get(prop.node.key.id.name); - const { - getId, - setId, - initAdded - } = privateName; - if (initAdded) return; - const isAccessor = getId || setId; - if (isAccessor) { - return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state); + if (privateName.initAdded) return; + if (!newHelpers(state)) { + const isGetterOrSetter = privateName.getId || privateName.setId; + if (isGetterOrSetter) { + return buildPrivateAccessorInitialization(ref, prop, privateNamesMap, state); + } } return buildPrivateInstanceMethodInitialization(ref, prop, privateNamesMap, state); } @@ -568,8 +721,8 @@ function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) { initAdded } = privateName; if (initAdded) return; - const isAccessor = getId || setId; - if (isAccessor) { + const isGetterOrSetter = getId || setId; + if (isGetterOrSetter) { privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { initAdded: true })); @@ -592,7 +745,7 @@ function buildPrivateStaticMethodInitLoose(ref, prop, state, privateNamesMap) { }); `, prop); } -function buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties = false) { +function buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties = false) { const privateName = privateNamesMap.get(prop.node.key.id.name); const { id, @@ -609,25 +762,58 @@ function buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsPro generator, async } = prop.node; - const isGetter = getId && !getterDeclared && params.length === 0; - const isSetter = setId && !setterDeclared && params.length > 0; + const isGetter = getId && params.length === 0; + const isSetter = setId && params.length > 0; + if (isGetter && getterDeclared || isSetter && setterDeclared) { + privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { + initAdded: true + })); + return null; + } + if (newHelpers(file) && (isGetter || isSetter) && !privateFieldsAsSymbolsOrProperties) { + const scope = prop.get("body").scope; + const thisArg = scope.generateUidIdentifier("this"); + const state = { + thisRef: thisArg, + argumentsPath: [] + }; + prop.traverse(thisContextVisitor, state); + if (state.argumentsPath.length) { + const argumentsId = scope.generateUidIdentifier("arguments"); + scope.push({ + id: argumentsId, + init: _core.template.expression.ast`[].slice.call(arguments, 1)` + }); + for (const path of state.argumentsPath) { + path.replaceWith(_core.types.cloneNode(argumentsId)); + } + } + params.unshift(_core.types.cloneNode(thisArg)); + } let declId = methodId; if (isGetter) { privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { - getterDeclared: true + getterDeclared: true, + initAdded: true })); declId = getId; } else if (isSetter) { privateNamesMap.set(prop.node.key.id.name, Object.assign({}, privateName, { - setterDeclared: true + setterDeclared: true, + initAdded: true })); declId = setId; - } else if (isStatic && !privateFieldsAsProperties) { + } else if (isStatic && !privateFieldsAsSymbolsOrProperties) { declId = id; } return inheritPropComments(_core.types.functionDeclaration(_core.types.cloneNode(declId), params, body, generator, async), prop); } const thisContextVisitor = _core.traverse.visitors.merge([{ + Identifier(path, state) { + if (state.argumentsPath && path.node.name === "arguments") { + state.argumentsPath.push(path); + } + }, UnaryExpression(path) { const { node @@ -641,7 +827,7 @@ const thisContextVisitor = _core.traverse.visitors.merge([{ }, ThisExpression(path, state) { state.needsClassRef = true; - path.replaceWith(_core.types.cloneNode(state.classRef)); + path.replaceWith(_core.types.cloneNode(state.thisRef)); }, MetaProperty(path) { const { @@ -657,21 +843,21 @@ const innerReferencesVisitor = { ReferencedIdentifier(path, state) { if (path.scope.bindingIdentifierEquals(path.node.name, state.innerBinding)) { state.needsClassRef = true; - path.node.name = state.classRef.name; + path.node.name = state.thisRef.name; } } }; function replaceThisContext(path, ref, innerBindingRef) { - var _state$classRef; + var _state$thisRef; const state = { - classRef: ref, + thisRef: ref, needsClassRef: false, innerBinding: innerBindingRef }; if (!path.isMethod()) { path.traverse(thisContextVisitor, state); } - if (innerBindingRef != null && (_state$classRef = state.classRef) != null && _state$classRef.name && state.classRef.name !== innerBindingRef.name) { + if (innerBindingRef != null && (_state$thisRef = state.thisRef) != null && _state$thisRef.name && state.thisRef.name !== innerBindingRef.name) { path.traverse(innerReferencesVisitor, state); } return state.needsClassRef; @@ -693,7 +879,7 @@ function inheritPropComments(node, prop) { _core.types.inheritInnerComments(node, prop.node); return node; } -function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPublicClassFields, privateFieldsAsProperties, constantSuper, innerBindingRef) { +function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPublicClassFields, privateFieldsAsSymbolsOrProperties, noUninitializedPrivateFieldAccess, constantSuper, innerBindingRef) { var _ref, _ref2; let classRefFlags = 0; let injectSuperRef; @@ -707,7 +893,7 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPu (_injectSuperRef = injectSuperRef) != null ? _injectSuperRef : injectSuperRef = props[0].scope.generateUidIdentifierBasedOnNode(superRef); return injectSuperRef; }; - const classRefForInnerBinding = (_ref = ref) != null ? _ref : props[0].scope.generateUidIdentifier("class"); + const classRefForInnerBinding = (_ref = ref) != null ? _ref : props[0].scope.generateUidIdentifier((innerBindingRef == null ? void 0 : innerBindingRef.name) || "Class"); (_ref2 = ref) != null ? _ref2 : ref = _core.types.cloneNode(innerBindingRef); for (const prop of props) { prop.isClassProperty() && ts.assertFieldTransformed(prop); @@ -752,11 +938,15 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPu } break; } - case isStatic && isPrivate && isField && privateFieldsAsProperties: + case isStatic && isPrivate && isField && privateFieldsAsSymbolsOrProperties: staticNodes.push(buildPrivateFieldInitLoose(_core.types.cloneNode(ref), prop, privateNamesMap)); break; - case isStatic && isPrivate && isField && !privateFieldsAsProperties: - staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap)); + case isStatic && isPrivate && isField && !privateFieldsAsSymbolsOrProperties: + if (!newHelpers(file)) { + staticNodes.push(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap)); + } else { + staticNodes.push(buildPrivateStaticFieldInitSpec(prop, privateNamesMap, noUninitializedPrivateFieldAccess)); + } break; case isStatic && isPublic && isField && setPublicClassFields: if (!isNameOrLength(prop.node)) { @@ -766,27 +956,29 @@ function buildFieldsInitNodes(ref, superRef, props, privateNamesMap, file, setPu case isStatic && isPublic && isField && !setPublicClassFields: staticNodes.push(buildPublicFieldInitSpec(_core.types.cloneNode(ref), prop, file)); break; - case isInstance && isPrivate && isField && privateFieldsAsProperties: + case isInstance && isPrivate && isField && privateFieldsAsSymbolsOrProperties: instanceNodes.push(buildPrivateFieldInitLoose(_core.types.thisExpression(), prop, privateNamesMap)); break; - case isInstance && isPrivate && isField && !privateFieldsAsProperties: + case isInstance && isPrivate && isField && !privateFieldsAsSymbolsOrProperties: instanceNodes.push(buildPrivateInstanceFieldInitSpec(_core.types.thisExpression(), prop, privateNamesMap, file)); break; - case isInstance && isPrivate && isMethod && privateFieldsAsProperties: + case isInstance && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties: instanceNodes.unshift(buildPrivateMethodInitLoose(_core.types.thisExpression(), prop, privateNamesMap)); - pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties)); + pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties)); break; - case isInstance && isPrivate && isMethod && !privateFieldsAsProperties: + case isInstance && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties: instanceNodes.unshift(buildPrivateInstanceMethodInitSpec(_core.types.thisExpression(), prop, privateNamesMap, file)); - pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties)); + pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties)); break; - case isStatic && isPrivate && isMethod && !privateFieldsAsProperties: - staticNodes.unshift(buildPrivateStaticFieldInitSpec(prop, privateNamesMap)); - pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties)); + case isStatic && isPrivate && isMethod && !privateFieldsAsSymbolsOrProperties: + if (!newHelpers(file)) { + staticNodes.unshift(buildPrivateStaticFieldInitSpecOld(prop, privateNamesMap)); + } + pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties)); break; - case isStatic && isPrivate && isMethod && privateFieldsAsProperties: + case isStatic && isPrivate && isMethod && privateFieldsAsSymbolsOrProperties: staticNodes.unshift(buildPrivateStaticMethodInitLoose(_core.types.cloneNode(ref), prop, file, privateNamesMap)); - pureStaticNodes.push(buildPrivateMethodDeclaration(prop, privateNamesMap, privateFieldsAsProperties)); + pureStaticNodes.push(buildPrivateMethodDeclaration(file, prop, privateNamesMap, privateFieldsAsSymbolsOrProperties)); break; case isInstance && isPublic && isField && setPublicClassFields: instanceNodes.push(buildPublicFieldInitLoose(_core.types.thisExpression(), prop)); -- cgit v1.2.3