shift-spidermonkey-converter
Version:
convert ASTs between Shift and SpiderMonkey formats
625 lines (605 loc) • 98.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); /**
* Copyright 2014 Shape Security, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License")
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var _shiftAst = require("shift-ast");
var Shift = _interopRequireWildcard(_shiftAst);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
// convert SpiderMonkey AST format to Shift AST format
var ShiftConverter = {
convert: function convert(node) {
if (node == null) {
return null;
}
return this["convert" + node.type](node);
},
convertAssignmentExpression: function convertAssignmentExpression(node) {
var binding = this.toBinding(node.left),
expression = this.toExpression(node.right),
operator = node.operator;
if (operator === "=") return new Shift.AssignmentExpression({ binding: binding, expression: expression });else return new Shift.CompoundAssignmentExpression({ binding: binding, expression: expression, operator: operator });
},
convertAssignmentPattern: function convertAssignmentPattern(node) {
return new Shift.BindingWithDefault({
binding: this.toBinding(node.left),
init: this.convert(node.right)
});
},
convertArrayExpression: function convertArrayExpression(node) {
return new Shift.ArrayExpression({ elements: node.elements.map(this.convert.bind(this)) });
},
convertArrayPattern: function convertArrayPattern(node) {
var _convertElements = this.convertElements(node.elements),
_convertElements2 = _slicedToArray(_convertElements, 2),
elements = _convertElements2[0],
restElement = _convertElements2[1];
return new Shift.ArrayBinding({ elements: elements, restElement: restElement });
},
convertArrowFunctionExpression: function convertArrowFunctionExpression(node) {
return new Shift.ArrowExpression({
params: new Shift.FormalParameters(this.convertFunctionParams(node)),
body: node.expression ? this.toExpression(node.body) : this.convertStatementsToFunctionBody(node.body.body)
});
},
convertBlockStatement: function convertBlockStatement(node) {
return new Shift.BlockStatement({ block: this.convertBlock(node) });
},
convertBinaryExpression: function convertBinaryExpression(node) {
return new Shift.BinaryExpression({
operator: node.operator,
left: this.toExpression(node.left),
right: this.toExpression(node.right)
});
},
convertBreakStatement: function convertBreakStatement(node) {
return new Shift.BreakStatement({ label: node.label ? node.label.name : null });
},
convertCallExpression: function convertCallExpression(node) {
var callee = node.callee.type === "Super" ? this.convertSuper(node.callee) : this.toExpression(node.callee);
return new Shift.CallExpression({ callee: callee, arguments: node.arguments.map(this.toArgument.bind(this)) });
},
convertCatchClause: function convertCatchClause(node) {
return new Shift.CatchClause({
binding: this.toBinding(node.param),
body: this.convertBlock(node.body)
});
},
convertClassDeclaration: function convertClassDeclaration(node) {
return new Shift.ClassDeclaration({
name: this.toBinding(node.id),
super: this.toExpression(node.superClass),
elements: this.convert(node.body)
});
},
convertClassExpression: function convertClassExpression(node) {
var name = node.id == null ? null : this.toBinding(node.id);
var spr = this.toExpression(node.superClass);
var elements = this.convert(node.body);
return new Shift.ClassExpression({ name: name, super: spr, elements: elements });
},
convertClassBody: function convertClassBody(node) {
return node.body.map(this.convert.bind(this));
},
convertConditionalExpression: function convertConditionalExpression(node) {
return new Shift.ConditionalExpression({
test: this.toExpression(node.test),
consequent: this.toExpression(node.consequent),
alternate: this.toExpression(node.alternate)
});
},
convertContinueStatement: function convertContinueStatement(node) {
return new Shift.ContinueStatement({ label: node.label ? node.label.name : null });
},
convertDoWhileStatement: function convertDoWhileStatement(node) {
return new Shift.DoWhileStatement({
body: this.convert(node.body),
test: this.convert(node.test)
});
},
convertDebuggerStatement: function convertDebuggerStatement() {
return new Shift.DebuggerStatement();
},
convertEmptyStatement: function convertEmptyStatement() {
return new Shift.EmptyStatement();
},
convertExportAllDeclaration: function convertExportAllDeclaration(node) {
return new Shift.ExportAllFrom({ moduleSpecifier: node.source.value });
},
convertExportDefaultDeclaration: function convertExportDefaultDeclaration(node) {
return new Shift.ExportDefault({ body: this.convert(node.declaration) });
},
convertExportNamedDeclaration: function convertExportNamedDeclaration(node) {
if (node.declaration != null) {
return new Shift.Export({
declaration: node.declaration.type === "VariableDeclaration" ? this.convertVariableDeclaration(node.declaration, true) : this.convert(node.declaration)
});
}
return new Shift.ExportFrom({
moduleSpecifier: node.source != null ? node.source.value : null,
namedExports: node.specifiers.map(this.convert.bind(this))
});
},
convertExportSpecifier: function convertExportSpecifier(node) {
return new Shift.ExportSpecifier({
exportedName: node.exported.name,
name: node.local.name !== node.exported.name ? node.local.name : null
});
},
convertExpressionStatement: function convertExpressionStatement(node) {
return new Shift.ExpressionStatement({ expression: this.toExpression(node.expression) });
},
convertForStatement: function convertForStatement(node) {
var init = node.init != null && node.init.type === "VariableDeclaration" ? this.convertVariableDeclaration(node.init, true) : this.toExpression(node.init);
return new Shift.ForStatement({
init: init,
test: this.toExpression(node.test),
update: this.toExpression(node.update),
body: this.convert(node.body)
});
},
convertForOfStatement: function convertForOfStatement(node) {
var left = node.left.type === "VariableDeclaration" ? this.convertVariableDeclaration(node.left, true) : this.toBinding(node.left);
return new Shift.ForOfStatement({
left: left,
right: this.toExpression(node.right),
body: this.convert(node.body)
});
},
convertForInStatement: function convertForInStatement(node) {
var left = node.left.type === "VariableDeclaration" ? this.convertVariableDeclaration(node.left, true) : this.toBinding(node.left);
return new Shift.ForInStatement({
left: left,
right: this.toExpression(node.right),
body: this.convert(node.body)
});
},
convertFunctionDeclaration: function convertFunctionDeclaration(node) {
return new Shift.FunctionDeclaration({
isGenerator: node.generator,
name: this.toBinding(node.id),
params: new Shift.FormalParameters(this.convertFunctionParams(node)),
body: this.convertStatementsToFunctionBody(node.body.body)
});
},
convertFunctionExpression: function convertFunctionExpression(node) {
return new Shift.FunctionExpression({
isGenerator: node.generator,
name: this.toBinding(node.id),
params: new Shift.FormalParameters(this.convertFunctionParams(node)),
body: this.convertStatementsToFunctionBody(node.body.body)
});
},
convertIfStatement: function convertIfStatement(node) {
return new Shift.IfStatement({
test: this.toExpression(node.test),
consequent: this.convert(node.consequent),
alternate: this.convert(node.alternate)
});
},
convertImportDeclaration: function convertImportDeclaration(node) {
var hasDefaultSpecifier = node.specifiers.some(function (s) {
return s.type === "ImportDefaultSpecifier";
});
if (node.specifiers.some(function (s) {
return s.type === "ImportNamespaceSpecifier";
})) return this.toImportNamespace(node, hasDefaultSpecifier);
var namedImports = node.specifiers.map(this.convert.bind(this));
if (hasDefaultSpecifier) namedImports.shift();
return new Shift.Import({
moduleSpecifier: node.source.value,
namedImports: namedImports,
defaultBinding: hasDefaultSpecifier ? this.toBinding(node.specifiers[0]) : null
});
},
convertImportDefaultSpecifier: function convertImportDefaultSpecifier(node) {
return this.toBinding(node.local);
},
convertImportNamespaceSpecifier: function convertImportNamespaceSpecifier(node) {
return this.toBinding(node.local);
},
convertImportSpecifier: function convertImportSpecifier(node) {
return new Shift.ImportSpecifier({ name: node.imported.name, binding: this.toBinding(node.local) });
},
convertLiteral: function convertLiteral(node) {
switch (_typeof(node.value)) {
case "number":
if (node.value === 1 / 0) {
return new Shift.LiteralInfinityExpression();
}
return new Shift.LiteralNumericExpression(node);
case "string":
return new Shift.LiteralStringExpression(node);
case "boolean":
return new Shift.LiteralBooleanExpression(node);
default:
if (node.hasOwnProperty("regex")) {
return new Shift.LiteralRegExpExpression(node.regex);
} else {
return new Shift.LiteralNullExpression();
}
}
},
convertLabeledStatement: function convertLabeledStatement(node) {
return new Shift.LabeledStatement({
label: node.label.name,
body: this.convert(node.body)
});
},
convertLogicalExpression: function convertLogicalExpression(node) {
return this.convertBinaryExpression(node);
},
convertMemberExpression: function convertMemberExpression(node) {
var obj = node.object.type === "Super" ? this.convertSuper(node.object) : this.toExpression(node.object);
if (node.computed) {
return new Shift.ComputedMemberExpression({
object: obj,
expression: this.toExpression(node.property)
});
} else {
return new Shift.StaticMemberExpression({
object: obj,
property: node.property.name
});
}
},
convertMetaProperty: function convertMetaProperty(node) {
if (node.meta === "new" && node.property === "target") {
return new Shift.NewTargetExpression();
}
return null;
},
convertMethodDefinition: function convertMethodDefinition(node) {
return new Shift.ClassElement({ isStatic: node.static, method: this.toMethod(node) });
},
convertNewExpression: function convertNewExpression(node) {
return new Shift.NewExpression({
callee: this.toArgument(node.callee),
arguments: node.arguments.map(this.toArgument.bind(this))
});
},
convertObjectExpression: function convertObjectExpression(node) {
return new Shift.ObjectExpression({ properties: node.properties.map(this.convert.bind(this)) });
},
convertObjectPattern: function convertObjectPattern(node) {
return new Shift.ObjectBinding({ properties: node.properties.map(this.toBinding.bind(this)) });
},
convertProgram: function convertProgram(node) {
var directives = node.directives ? node.directives.map(this.convertDirective.bind(this)) : [],
statements = node.body.map(this.convert.bind(this));
if (node.sourceType === "module") {
return new Shift.Module({ directives: directives, items: statements });
}
return new Shift.Script({ directives: directives, statements: statements });
},
convertProperty: function convertProperty(node) {
switch (node.kind) {
case "init":
if (node.method) {
return this.toMethod(node);
} else {
return this.toInitProperty(node);
}
case "get":
return this.toGetter(node);
case "set":
return this.toSetter(node);
default:
throw Error("Unknown kind of Property: " + node.kind);
}
},
convertRestElement: function convertRestElement(node) {
return this.toBinding(node.argument);
},
convertReturnStatement: function convertReturnStatement(node) {
return new Shift.ReturnStatement({ expression: this.toExpression(node.argument) });
},
convertSequenceExpression: function convertSequenceExpression(node) {
var expr = this.toExpression(node.expressions[0]);
for (var i = 1; i < node.expressions.length; i++) {
expr = new Shift.BinaryExpression({
operator: ",",
left: expr,
right: this.toExpression(node.expressions[i])
});
}
return expr;
},
convertSpreadElement: function convertSpreadElement(node) {
return new Shift.SpreadElement({ expression: this.toExpression(node.argument) });
},
convertSuper: function convertSuper() {
return new Shift.Super();
},
convertSwitchCase: function convertSwitchCase(node) {
if (node.test) {
return new Shift.SwitchCase({
test: this.convert(node.test),
consequent: node.consequent.map(this.convert.bind(this))
});
}
return new Shift.SwitchDefault({ consequent: node.consequent.map(this.convert.bind(this)) });
},
convertSwitchStatement: function convertSwitchStatement(node) {
if (!node.cases.every(function (c) {
return c.test != null;
})) {
var scs = node.cases.map(this.convertSwitchCase.bind(this));
for (var i = 0; i < scs.length; i++) {
if (scs[i].type === "SwitchDefault") {
break;
}
}
return new Shift.SwitchStatementWithDefault({
discriminant: this.toExpression(node.discriminant),
preDefaultCases: scs.slice(0, i),
defaultCase: scs[i],
postDefaultCases: scs.slice(i + 1)
});
} else {
return new Shift.SwitchStatement({
discriminant: this.toExpression(node.discriminant),
cases: node.cases.map(this.convertSwitchCase.bind(this))
});
}
},
convertTaggedTemplateExpression: function convertTaggedTemplateExpression(node) {
var _this = this;
var elts = [];
node.quasi.quasis.forEach(function (e, i) {
elts.push(_this.convertTemplateElement(e));
if (i < node.quasi.expressions.length) elts.push(_this.toExpression(node.quasi.expressions[i]));
});
return new Shift.TemplateExpression({
tag: this.toExpression(node.tag),
elements: elts
});
},
convertTemplateElement: function convertTemplateElement(node) {
return new Shift.TemplateElement({ rawValue: node.value.raw });
},
convertTemplateLiteral: function convertTemplateLiteral(node, tag) {
var _this2 = this;
var elts = [];
node.quasis.forEach(function (e, i) {
elts.push(_this2.convertTemplateElement(e));
if (i < node.expressions.length) elts.push(_this2.toExpression(node.expressions[i]));
});
return new Shift.TemplateExpression({
tag: tag != null ? this.convert(tag) : null,
elements: elts
});
},
convertThisExpression: function convertThisExpression() {
return new Shift.ThisExpression();
},
convertThrowStatement: function convertThrowStatement(node) {
return new Shift.ThrowStatement({ expression: this.toExpression(node.argument) });
},
convertTryStatement: function convertTryStatement(node) {
if (node.finalizer == null) {
return new Shift.TryCatchStatement({
body: this.convertBlock(node.block),
catchClause: this.convertCatchClause(node.handler)
});
} else if (node.handler == null) {
return new Shift.TryFinallyStatement({
body: this.convertBlock(node.block),
catchClause: null,
finalizer: this.convertBlock(node.finalizer)
});
} else {
return new Shift.TryFinallyStatement({
body: this.convertBlock(node.block),
catchClause: this.convertCatchClause(node.handler),
finalizer: this.convertBlock(node.finalizer)
});
}
},
convertUnaryExpression: function convertUnaryExpression(node) {
return new Shift.UnaryExpression({
operator: node.operator,
operand: this.toExpression(node.argument)
});
},
convertUpdateExpression: function convertUpdateExpression(node) {
return new Shift.UpdateExpression({
isPrefix: node.prefix,
operator: node.operator,
operand: this.toBinding(node.argument)
});
},
convertVariableDeclaration: function convertVariableDeclaration(node, isDeclaration) {
var declaration = new Shift.VariableDeclaration({
kind: node.kind,
declarators: node.declarations.map(this.convertVariableDeclarator.bind(this))
});
if (isDeclaration) return declaration;
return new Shift.VariableDeclarationStatement({ declaration: declaration });
},
convertVariableDeclarator: function convertVariableDeclarator(node) {
return new Shift.VariableDeclarator({
binding: this.toBinding(node.id),
init: this.convert(node.init)
});
},
convertWhileStatement: function convertWhileStatement(node) {
return new Shift.WhileStatement({ test: this.convert(node.test), body: this.convert(node.body) });
},
convertWithStatement: function convertWithStatement(node) {
return new Shift.WithStatement({ object: this.convert(node.object), body: this.convert(node.body) });
},
convertYieldExpression: function convertYieldExpression(node) {
if (node.delegate) return new Shift.YieldGeneratorExpression({ expression: this.toExpression(node.argument) });
return new Shift.YieldExpression({ expression: this.toExpression(node.argument) });
},
// auxiliary methods
toBinding: function toBinding(node) {
if (node == null) return null;
switch (node.type) {
case "Identifier":
return new Shift.BindingIdentifier({ name: node.name });
case "Property":
if (node.shorthand) {
return new Shift.BindingPropertyIdentifier({
binding: this.toBinding(node.key),
init: this.toExpression(node.value.right)
});
} else {
return new Shift.BindingPropertyProperty({
name: this.toPropertyName(node.key, node.computed),
binding: this.toBinding(node.value)
});
}
default:
return this.convert(node);
}
},
convertBlock: function convertBlock(node) {
return new Shift.Block({ statements: node.body.map(this.convert.bind(this)) });
},
toExpression: function toExpression(node) {
if (node == null) return null;
switch (node.type) {
case "Literal":
return this.convertLiteral(node);
case "Identifier":
return new Shift.IdentifierExpression({ name: node.name });
case "MetaProperty":
return new Shift.NewTargetExpression();
case "TemplateLiteral":
return this.convertTemplateLiteral(node);
default:
return this.convert(node);
}
},
toArgument: function toArgument(node) {
if (node.type === "SpreadElement") {
return this.convertSpreadElement(node);
}
return this.toExpression(node);
},
convertDirective: function convertDirective(node) {
node = node.expression;
return new Shift.Directive({ rawValue: node.value });
},
convertStatementsToFunctionBody: function convertStatementsToFunctionBody(stmts) {
for (var i = 0; i < stmts.length; i++) {
if (!stmts[i].hasOwnProperty("directive")) {
break;
}
}
return new Shift.FunctionBody({
directives: stmts.slice(0, i).map(this.convertDirective.bind(this)),
statements: stmts.slice(i).map(this.convert.bind(this))
});
},
toPropertyName: function toPropertyName(node, computed) {
if (computed) {
return new Shift.ComputedPropertyName({ expression: this.toExpression(node) });
} else {
return new Shift.StaticPropertyName({
value: node.type === "Identifier" ? node.name : node.value.toString()
});
}
},
toInitProperty: function toInitProperty(node) {
var name = this.toPropertyName(node.key, node.computed);
if (node.shorthand) {
return new Shift.ShorthandProperty({ name: node.key.name });
}
return new Shift.DataProperty({ name: name, expression: this.toExpression(node.value) });
},
toMethod: function toMethod(node) {
var name = this.toPropertyName(node.key, node.computed);
var body = this.convertStatementsToFunctionBody(node.value.body.body);
switch (node.kind) {
case "method":
case "constructor":
case "init":
return new Shift.Method({
isGenerator: node.value.generator,
name: name,
params: new Shift.FormalParameters(this.convertFunctionParams(node.value)),
body: body
});
case "get":
return new Shift.Getter({
name: name,
body: body
});
case "set":
return new Shift.Setter({
name: name,
param: this.convertFunctionParams(node.value).items[0],
body: body
});
}
},
toGetter: function toGetter(node) {
return new Shift.Getter({
name: this.toPropertyName(node.key, node.computed),
body: this.convertStatementsToFunctionBody(node.value.body.body)
});
},
toSetter: function toSetter(node) {
var params = this.convertFunctionParams(node.value);
return new Shift.Setter({
name: this.toPropertyName(node.key, node.computed),
body: this.convertStatementsToFunctionBody(node.value.body.body),
param: params.items[0] || params.rest
});
},
convertElements: function convertElements(elts) {
var count = elts.length;
if (count === 0) {
return [[], null];
} else if (elts[count - 1] !== null && elts[count - 1].type === "RestElement") {
return [elts.slice(0, count - 1).map(this.toBinding.bind(this)), this.toBinding(elts[count - 1])];
} else {
return [elts.map(this.toBinding.bind(this)), null];
}
},
convertFunctionParams: function convertFunctionParams(node) {
var _this3 = this;
var _convertElements3 = this.convertElements(node.params),
_convertElements4 = _slicedToArray(_convertElements3, 2),
items = _convertElements4[0],
rest = _convertElements4[1];
if (node.defaults.length > 0) {
items = items.map(function (v, i) {
var d = node.defaults[i];
if (d != null) {
return new Shift.BindingWithDefault({ binding: v, init: _this3.convert(d) });
}
return v;
});
}
return { items: items, rest: rest };
},
toImportNamespace: function toImportNamespace(node, hasDefaultSpecifier) {
var firstBinding = this.toBinding(node.specifiers[0]);
return new Shift.ImportNamespace({
moduleSpecifier: node.source.value,
namespaceBinding: hasDefaultSpecifier ? this.toBinding(node.specifiers[1]) : firstBinding,
defaultBinding: hasDefaultSpecifier ? firstBinding : null
});
}
};
exports.default = ShiftConverter;
//# sourceMappingURL=data:application/json;base64,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