You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
564 lines
17 KiB
564 lines
17 KiB
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = transformClass;
|
|
|
|
var _helperFunctionName = _interopRequireDefault(require("@babel/helper-function-name"));
|
|
|
|
var _helperReplaceSupers = _interopRequireWildcard(require("@babel/helper-replace-supers"));
|
|
|
|
var _helperOptimiseCallExpression = _interopRequireDefault(require("@babel/helper-optimise-call-expression"));
|
|
|
|
var defineMap = _interopRequireWildcard(require("@babel/helper-define-map"));
|
|
|
|
var _core = require("@babel/core");
|
|
|
|
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function buildConstructor(classRef, constructorBody, node) {
|
|
const func = _core.types.functionDeclaration(_core.types.cloneNode(classRef), [], constructorBody);
|
|
|
|
_core.types.inherits(func, node);
|
|
|
|
return func;
|
|
}
|
|
|
|
function transformClass(path, file, builtinClasses, isLoose) {
|
|
const classState = {
|
|
parent: undefined,
|
|
scope: undefined,
|
|
node: undefined,
|
|
path: undefined,
|
|
file: undefined,
|
|
classId: undefined,
|
|
classRef: undefined,
|
|
superName: undefined,
|
|
superReturns: [],
|
|
isDerived: false,
|
|
extendsNative: false,
|
|
construct: undefined,
|
|
constructorBody: undefined,
|
|
userConstructor: undefined,
|
|
userConstructorPath: undefined,
|
|
hasConstructor: false,
|
|
instancePropBody: [],
|
|
instancePropRefs: {},
|
|
staticPropBody: [],
|
|
body: [],
|
|
superThises: [],
|
|
pushedConstructor: false,
|
|
pushedInherits: false,
|
|
protoAlias: null,
|
|
isLoose: false,
|
|
hasInstanceDescriptors: false,
|
|
hasStaticDescriptors: false,
|
|
instanceMutatorMap: {},
|
|
staticMutatorMap: {}
|
|
};
|
|
|
|
const setState = newState => {
|
|
Object.assign(classState, newState);
|
|
};
|
|
|
|
const findThisesVisitor = _core.traverse.visitors.merge([_helperReplaceSupers.environmentVisitor, {
|
|
ThisExpression(path) {
|
|
classState.superThises.push(path);
|
|
}
|
|
|
|
}]);
|
|
|
|
function pushToMap(node, enumerable, kind = "value", scope) {
|
|
let mutatorMap;
|
|
|
|
if (node.static) {
|
|
setState({
|
|
hasStaticDescriptors: true
|
|
});
|
|
mutatorMap = classState.staticMutatorMap;
|
|
} else {
|
|
setState({
|
|
hasInstanceDescriptors: true
|
|
});
|
|
mutatorMap = classState.instanceMutatorMap;
|
|
}
|
|
|
|
const map = defineMap.push(mutatorMap, node, kind, classState.file, scope);
|
|
|
|
if (enumerable) {
|
|
map.enumerable = _core.types.booleanLiteral(true);
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
function maybeCreateConstructor() {
|
|
let hasConstructor = false;
|
|
const paths = classState.path.get("body.body");
|
|
|
|
for (const path of paths) {
|
|
hasConstructor = path.equals("kind", "constructor");
|
|
if (hasConstructor) break;
|
|
}
|
|
|
|
if (hasConstructor) return;
|
|
let params, body;
|
|
|
|
if (classState.isDerived) {
|
|
const constructor = _core.template.expression.ast`
|
|
(function () {
|
|
super(...arguments);
|
|
})
|
|
`;
|
|
params = constructor.params;
|
|
body = constructor.body;
|
|
} else {
|
|
params = [];
|
|
body = _core.types.blockStatement([]);
|
|
}
|
|
|
|
classState.path.get("body").unshiftContainer("body", _core.types.classMethod("constructor", _core.types.identifier("constructor"), params, body));
|
|
}
|
|
|
|
function buildBody() {
|
|
maybeCreateConstructor();
|
|
pushBody();
|
|
verifyConstructor();
|
|
|
|
if (classState.userConstructor) {
|
|
const {
|
|
constructorBody,
|
|
userConstructor,
|
|
construct
|
|
} = classState;
|
|
constructorBody.body = constructorBody.body.concat(userConstructor.body.body);
|
|
|
|
_core.types.inherits(construct, userConstructor);
|
|
|
|
_core.types.inherits(constructorBody, userConstructor.body);
|
|
}
|
|
|
|
pushDescriptors();
|
|
}
|
|
|
|
function pushBody() {
|
|
const classBodyPaths = classState.path.get("body.body");
|
|
|
|
for (const path of classBodyPaths) {
|
|
const node = path.node;
|
|
|
|
if (path.isClassProperty()) {
|
|
throw path.buildCodeFrameError("Missing class properties transform.");
|
|
}
|
|
|
|
if (node.decorators) {
|
|
throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
|
|
}
|
|
|
|
if (_core.types.isClassMethod(node)) {
|
|
const isConstructor = node.kind === "constructor";
|
|
const replaceSupers = new _helperReplaceSupers.default({
|
|
methodPath: path,
|
|
objectRef: classState.classRef,
|
|
superRef: classState.superName,
|
|
isLoose: classState.isLoose,
|
|
file: classState.file
|
|
});
|
|
replaceSupers.replace();
|
|
const superReturns = [];
|
|
path.traverse(_core.traverse.visitors.merge([_helperReplaceSupers.environmentVisitor, {
|
|
ReturnStatement(path) {
|
|
if (!path.getFunctionParent().isArrowFunctionExpression()) {
|
|
superReturns.push(path);
|
|
}
|
|
}
|
|
|
|
}]));
|
|
|
|
if (isConstructor) {
|
|
pushConstructor(superReturns, node, path);
|
|
} else {
|
|
pushMethod(node, path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearDescriptors() {
|
|
setState({
|
|
hasInstanceDescriptors: false,
|
|
hasStaticDescriptors: false,
|
|
instanceMutatorMap: {},
|
|
staticMutatorMap: {}
|
|
});
|
|
}
|
|
|
|
function pushDescriptors() {
|
|
pushInheritsToBody();
|
|
const {
|
|
body
|
|
} = classState;
|
|
let instanceProps;
|
|
let staticProps;
|
|
|
|
if (classState.hasInstanceDescriptors) {
|
|
instanceProps = defineMap.toClassObject(classState.instanceMutatorMap);
|
|
}
|
|
|
|
if (classState.hasStaticDescriptors) {
|
|
staticProps = defineMap.toClassObject(classState.staticMutatorMap);
|
|
}
|
|
|
|
if (instanceProps || staticProps) {
|
|
if (instanceProps) {
|
|
instanceProps = defineMap.toComputedObjectFromClass(instanceProps);
|
|
}
|
|
|
|
if (staticProps) {
|
|
staticProps = defineMap.toComputedObjectFromClass(staticProps);
|
|
}
|
|
|
|
let args = [_core.types.cloneNode(classState.classRef), _core.types.nullLiteral(), _core.types.nullLiteral()];
|
|
if (instanceProps) args[1] = instanceProps;
|
|
if (staticProps) args[2] = staticProps;
|
|
let lastNonNullIndex = 0;
|
|
|
|
for (let i = 0; i < args.length; i++) {
|
|
if (!_core.types.isNullLiteral(args[i])) lastNonNullIndex = i;
|
|
}
|
|
|
|
args = args.slice(0, lastNonNullIndex + 1);
|
|
body.push(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("createClass"), args)));
|
|
}
|
|
|
|
clearDescriptors();
|
|
}
|
|
|
|
function wrapSuperCall(bareSuper, superRef, thisRef, body) {
|
|
let bareSuperNode = bareSuper.node;
|
|
let call;
|
|
|
|
if (classState.isLoose) {
|
|
bareSuperNode.arguments.unshift(_core.types.thisExpression());
|
|
|
|
if (bareSuperNode.arguments.length === 2 && _core.types.isSpreadElement(bareSuperNode.arguments[1]) && _core.types.isIdentifier(bareSuperNode.arguments[1].argument, {
|
|
name: "arguments"
|
|
})) {
|
|
bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
|
|
bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("apply"));
|
|
} else {
|
|
bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("call"));
|
|
}
|
|
|
|
call = _core.types.logicalExpression("||", bareSuperNode, _core.types.thisExpression());
|
|
} else {
|
|
bareSuperNode = (0, _helperOptimiseCallExpression.default)(_core.types.callExpression(classState.file.addHelper("getPrototypeOf"), [_core.types.cloneNode(classState.classRef)]), _core.types.thisExpression(), bareSuperNode.arguments);
|
|
call = _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), [_core.types.thisExpression(), bareSuperNode]);
|
|
}
|
|
|
|
if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
|
|
if (classState.superThises.length) {
|
|
call = _core.types.assignmentExpression("=", thisRef(), call);
|
|
}
|
|
|
|
bareSuper.parentPath.replaceWith(_core.types.returnStatement(call));
|
|
} else {
|
|
bareSuper.replaceWith(_core.types.assignmentExpression("=", thisRef(), call));
|
|
}
|
|
}
|
|
|
|
function verifyConstructor() {
|
|
if (!classState.isDerived) return;
|
|
const path = classState.userConstructorPath;
|
|
const body = path.get("body");
|
|
path.traverse(findThisesVisitor);
|
|
|
|
let thisRef = function () {
|
|
const ref = path.scope.generateDeclaredUidIdentifier("this");
|
|
|
|
thisRef = () => _core.types.cloneNode(ref);
|
|
|
|
return ref;
|
|
};
|
|
|
|
for (const thisPath of classState.superThises) {
|
|
const {
|
|
node,
|
|
parentPath
|
|
} = thisPath;
|
|
|
|
if (parentPath.isMemberExpression({
|
|
object: node
|
|
})) {
|
|
thisPath.replaceWith(thisRef());
|
|
continue;
|
|
}
|
|
|
|
thisPath.replaceWith(_core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]));
|
|
}
|
|
|
|
const bareSupers = new Set();
|
|
path.traverse(_core.traverse.visitors.merge([_helperReplaceSupers.environmentVisitor, {
|
|
Super(path) {
|
|
const {
|
|
node,
|
|
parentPath
|
|
} = path;
|
|
|
|
if (parentPath.isCallExpression({
|
|
callee: node
|
|
})) {
|
|
bareSupers.add(parentPath);
|
|
}
|
|
}
|
|
|
|
}]));
|
|
let guaranteedSuperBeforeFinish = !!bareSupers.size;
|
|
|
|
for (const bareSuper of bareSupers) {
|
|
wrapSuperCall(bareSuper, classState.superName, thisRef, body);
|
|
|
|
if (guaranteedSuperBeforeFinish) {
|
|
bareSuper.find(function (parentPath) {
|
|
if (parentPath === path) {
|
|
return true;
|
|
}
|
|
|
|
if (parentPath.isLoop() || parentPath.isConditional() || parentPath.isArrowFunctionExpression()) {
|
|
guaranteedSuperBeforeFinish = false;
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
let wrapReturn;
|
|
|
|
if (classState.isLoose) {
|
|
wrapReturn = returnArg => {
|
|
const thisExpr = _core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]);
|
|
|
|
return returnArg ? _core.types.logicalExpression("||", returnArg, thisExpr) : thisExpr;
|
|
};
|
|
} else {
|
|
wrapReturn = returnArg => _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), [thisRef()].concat(returnArg || []));
|
|
}
|
|
|
|
const bodyPaths = body.get("body");
|
|
|
|
if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {
|
|
body.pushContainer("body", _core.types.returnStatement(guaranteedSuperBeforeFinish ? thisRef() : wrapReturn()));
|
|
}
|
|
|
|
for (const returnPath of classState.superReturns) {
|
|
returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument));
|
|
}
|
|
}
|
|
|
|
function pushMethod(node, path) {
|
|
const scope = path ? path.scope : classState.scope;
|
|
|
|
if (node.kind === "method") {
|
|
if (processMethod(node, scope)) return;
|
|
}
|
|
|
|
pushToMap(node, false, null, scope);
|
|
}
|
|
|
|
function processMethod(node, scope) {
|
|
if (classState.isLoose && !node.decorators) {
|
|
let {
|
|
classRef
|
|
} = classState;
|
|
|
|
if (!node.static) {
|
|
insertProtoAliasOnce();
|
|
classRef = classState.protoAlias;
|
|
}
|
|
|
|
const methodName = _core.types.memberExpression(_core.types.cloneNode(classRef), node.key, node.computed || _core.types.isLiteral(node.key));
|
|
|
|
let func = _core.types.functionExpression(null, node.params, node.body, node.generator, node.async);
|
|
|
|
_core.types.inherits(func, node);
|
|
|
|
const key = _core.types.toComputedKey(node, node.key);
|
|
|
|
if (_core.types.isStringLiteral(key)) {
|
|
func = (0, _helperFunctionName.default)({
|
|
node: func,
|
|
id: key,
|
|
scope
|
|
});
|
|
}
|
|
|
|
const expr = _core.types.expressionStatement(_core.types.assignmentExpression("=", methodName, func));
|
|
|
|
_core.types.inheritsComments(expr, node);
|
|
|
|
classState.body.push(expr);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function insertProtoAliasOnce() {
|
|
if (classState.protoAlias === null) {
|
|
setState({
|
|
protoAlias: classState.scope.generateUidIdentifier("proto")
|
|
});
|
|
|
|
const classProto = _core.types.memberExpression(classState.classRef, _core.types.identifier("prototype"));
|
|
|
|
const protoDeclaration = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(classState.protoAlias, classProto)]);
|
|
|
|
classState.body.push(protoDeclaration);
|
|
}
|
|
}
|
|
|
|
function pushConstructor(superReturns, method, path) {
|
|
if (path.scope.hasOwnBinding(classState.classRef.name)) {
|
|
path.scope.rename(classState.classRef.name);
|
|
}
|
|
|
|
setState({
|
|
userConstructorPath: path,
|
|
userConstructor: method,
|
|
hasConstructor: true,
|
|
superReturns
|
|
});
|
|
const {
|
|
construct
|
|
} = classState;
|
|
|
|
_core.types.inheritsComments(construct, method);
|
|
|
|
construct.params = method.params;
|
|
|
|
_core.types.inherits(construct.body, method.body);
|
|
|
|
construct.body.directives = method.body.directives;
|
|
pushConstructorToBody();
|
|
}
|
|
|
|
function pushConstructorToBody() {
|
|
if (classState.pushedConstructor) return;
|
|
classState.pushedConstructor = true;
|
|
|
|
if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {
|
|
pushDescriptors();
|
|
}
|
|
|
|
classState.body.push(classState.construct);
|
|
pushInheritsToBody();
|
|
}
|
|
|
|
function pushInheritsToBody() {
|
|
if (!classState.isDerived || classState.pushedInherits) return;
|
|
setState({
|
|
pushedInherits: true
|
|
});
|
|
classState.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [_core.types.cloneNode(classState.classRef), _core.types.cloneNode(classState.superName)])));
|
|
}
|
|
|
|
function setupClosureParamsArgs() {
|
|
const {
|
|
superName
|
|
} = classState;
|
|
const closureParams = [];
|
|
const closureArgs = [];
|
|
|
|
if (classState.isDerived) {
|
|
const arg = classState.extendsNative ? _core.types.callExpression(classState.file.addHelper("wrapNativeSuper"), [_core.types.cloneNode(superName)]) : _core.types.cloneNode(superName);
|
|
const param = classState.scope.generateUidIdentifierBasedOnNode(superName);
|
|
closureParams.push(param);
|
|
closureArgs.push(arg);
|
|
setState({
|
|
superName: _core.types.cloneNode(param)
|
|
});
|
|
}
|
|
|
|
return {
|
|
closureParams,
|
|
closureArgs
|
|
};
|
|
}
|
|
|
|
function classTransformer(path, file, builtinClasses, isLoose) {
|
|
setState({
|
|
parent: path.parent,
|
|
scope: path.scope,
|
|
node: path.node,
|
|
path,
|
|
file,
|
|
isLoose
|
|
});
|
|
setState({
|
|
classId: classState.node.id,
|
|
classRef: classState.node.id ? _core.types.identifier(classState.node.id.name) : classState.scope.generateUidIdentifier("class"),
|
|
superName: classState.node.superClass,
|
|
isDerived: !!classState.node.superClass,
|
|
constructorBody: _core.types.blockStatement([])
|
|
});
|
|
setState({
|
|
extendsNative: classState.isDerived && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true)
|
|
});
|
|
const {
|
|
classRef,
|
|
node,
|
|
constructorBody
|
|
} = classState;
|
|
setState({
|
|
construct: buildConstructor(classRef, constructorBody, node)
|
|
});
|
|
let {
|
|
body
|
|
} = classState;
|
|
const {
|
|
closureParams,
|
|
closureArgs
|
|
} = setupClosureParamsArgs();
|
|
buildBody();
|
|
|
|
if (!classState.isLoose) {
|
|
constructorBody.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("classCallCheck"), [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)])));
|
|
}
|
|
|
|
body = body.concat(classState.staticPropBody.map(fn => fn(_core.types.cloneNode(classState.classRef))));
|
|
const isStrict = path.isInStrictMode();
|
|
let constructorOnly = classState.classId && body.length === 1;
|
|
|
|
if (constructorOnly && !isStrict) {
|
|
for (const param of classState.construct.params) {
|
|
if (!_core.types.isIdentifier(param)) {
|
|
constructorOnly = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const directives = constructorOnly ? body[0].body.directives : [];
|
|
|
|
if (!isStrict) {
|
|
directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
|
|
}
|
|
|
|
if (constructorOnly) {
|
|
return _core.types.toExpression(body[0]);
|
|
}
|
|
|
|
body.push(_core.types.returnStatement(_core.types.cloneNode(classState.classRef)));
|
|
|
|
const container = _core.types.arrowFunctionExpression(closureParams, _core.types.blockStatement(body, directives));
|
|
|
|
return _core.types.callExpression(container, closureArgs);
|
|
}
|
|
|
|
return classTransformer(path, file, builtinClasses, isLoose);
|
|
}
|