325 lines
8.9 KiB
JavaScript
325 lines
8.9 KiB
JavaScript
"use strict";
|
|
|
|
var _ = require("lodash");
|
|
var util = require("../../../util");
|
|
var t = require("../../../types");
|
|
|
|
function returnBlock(expr) {
|
|
return t.blockStatement([t.returnStatement(expr)]);
|
|
}
|
|
|
|
function transformExpression(node, scope, state) {
|
|
if (!node) return;
|
|
|
|
return (function subTransform(node) {
|
|
switch (node.type) {
|
|
case "ConditionalExpression":
|
|
var callConsequent = subTransform(node.consequent);
|
|
var callAlternate = subTransform(node.alternate);
|
|
if (!callConsequent && !callAlternate) {
|
|
return;
|
|
}
|
|
|
|
// if ternary operator had tail recursion in value, convert to optimized if-statement
|
|
node.type = "IfStatement";
|
|
node.consequent = callConsequent ? t.toBlock(callConsequent) : returnBlock(node.consequent);
|
|
if (callAlternate) {
|
|
node.alternate = t.isIfStatement(callAlternate) ? callAlternate : t.toBlock(callAlternate);
|
|
} else {
|
|
node.alternate = returnBlock(node.alternate);
|
|
}
|
|
return [node];
|
|
|
|
case "LogicalExpression":
|
|
// only call in right-value of can be optimized
|
|
var callRight = subTransform(node.right);
|
|
if (!callRight) {
|
|
return;
|
|
}
|
|
|
|
// cache left value as it might have side-effects
|
|
var leftId = state.getLeftId();
|
|
var testExpr = t.assignmentExpression(
|
|
"=",
|
|
leftId,
|
|
node.left
|
|
);
|
|
|
|
if (node.operator === "&&") {
|
|
testExpr = t.unaryExpression("!", testExpr);
|
|
}
|
|
|
|
return [t.ifStatement(testExpr, returnBlock(leftId))].concat(callRight);
|
|
|
|
case "SequenceExpression":
|
|
var seq = node.expressions;
|
|
|
|
// only last element can be optimized
|
|
var lastCall = subTransform(seq[seq.length - 1]);
|
|
if (!lastCall) {
|
|
return;
|
|
}
|
|
|
|
// remove converted expression from sequence
|
|
// and convert to regular expression if needed
|
|
if (--seq.length === 1) {
|
|
node = seq[0];
|
|
}
|
|
|
|
return [t.expressionStatement(node)].concat(lastCall);
|
|
|
|
case "CallExpression":
|
|
var callee = node.callee, prop, thisBinding, args;
|
|
|
|
if (t.isMemberExpression(callee, { computed: false }) &&
|
|
t.isIdentifier(prop = callee.property)) {
|
|
switch (prop.name) {
|
|
case "call":
|
|
args = t.arrayExpression(node.arguments.slice(1));
|
|
break;
|
|
|
|
case "apply":
|
|
args = node.arguments[1] || t.identifier("undefined");
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
thisBinding = node.arguments[0];
|
|
callee = callee.object;
|
|
}
|
|
|
|
// only tail recursion can be optimized as for now
|
|
if (!t.isIdentifier(callee) || !scope.bindingEquals(callee.name, state.ownerId)) {
|
|
return;
|
|
}
|
|
|
|
state.hasTailRecursion = true;
|
|
|
|
var body = [];
|
|
|
|
if (!t.isThisExpression(thisBinding)) {
|
|
body.push(t.expressionStatement(t.assignmentExpression(
|
|
"=",
|
|
state.getThisId(),
|
|
thisBinding || t.identifier("undefined")
|
|
)));
|
|
}
|
|
|
|
if (!args) {
|
|
args = t.arrayExpression(node.arguments);
|
|
}
|
|
|
|
var argumentsId = state.getArgumentsId();
|
|
var params = state.getParams();
|
|
|
|
body.push(t.expressionStatement(t.assignmentExpression(
|
|
"=",
|
|
argumentsId,
|
|
args
|
|
)));
|
|
|
|
var i, param;
|
|
|
|
if (t.isArrayExpression(args)) {
|
|
var elems = args.elements;
|
|
for (i = 0; i < elems.length && i < params.length; i++) {
|
|
param = params[i];
|
|
var elem = elems[i] || (elems[i] = t.identifier("undefined"));
|
|
if (!param._isDefaultPlaceholder) {
|
|
elems[i] = t.assignmentExpression("=", param, elem);
|
|
}
|
|
}
|
|
} else {
|
|
state.setsArguments = true;
|
|
for (i = 0; i < params.length; i++) {
|
|
param = params[i];
|
|
if (!param._isDefaultPlaceholder) {
|
|
body.push(t.expressionStatement(t.assignmentExpression(
|
|
"=",
|
|
param,
|
|
t.memberExpression(argumentsId, t.literal(i), true)
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
|
|
body.push(t.continueStatement(state.getFunctionId()));
|
|
|
|
return body;
|
|
}
|
|
})(node);
|
|
}
|
|
|
|
// Looks for and replaces tail recursion calls.
|
|
var firstPass = {
|
|
enter: function (node, parent, scope, state) {
|
|
if (t.isReturnStatement(node)) {
|
|
this.skip();
|
|
return transformExpression(node.argument, scope, state);
|
|
} else if (t.isTryStatement(parent)) {
|
|
if (node === parent.block) {
|
|
this.skip();
|
|
} else if (parent.finalizer && node !== parent.finalizer) {
|
|
this.skip();
|
|
}
|
|
} else if (t.isFunction(node)) {
|
|
this.skip();
|
|
} else if (t.isVariableDeclaration(node)) {
|
|
this.skip();
|
|
state.vars.push(node);
|
|
}
|
|
}
|
|
};
|
|
|
|
// Hoists up function declarations, replaces `this` and `arguments` and
|
|
// marks them as needed.
|
|
var secondPass = {
|
|
enter: function (node, parent, scope, state) {
|
|
if (t.isThisExpression(node)) {
|
|
state.needsThis = true;
|
|
return state.getThisId();
|
|
} else if (t.isReferencedIdentifier(node, parent, { name: "arguments" })) {
|
|
state.needsArguments = true;
|
|
return state.getArgumentsId();
|
|
} else if (t.isFunction(node)) {
|
|
this.skip();
|
|
if (t.isFunctionDeclaration(node)) {
|
|
node = t.variableDeclaration("var", [
|
|
t.variableDeclarator(node.id, t.toExpression(node))
|
|
]);
|
|
node._blockHoist = 2;
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Optimizes recursion by removing `this` and `arguments`
|
|
// if they are not used.
|
|
var thirdPass = {
|
|
enter: function (node, parent, scope, state) {
|
|
if (!t.isExpressionStatement(node)) return;
|
|
var expr = node.expression;
|
|
if (!t.isAssignmentExpression(expr)) return;
|
|
if (!state.needsThis && expr.left === state.getThisId()) {
|
|
this.remove();
|
|
} else if (!state.needsArguments && expr.left === state.getArgumentsId() && t.isArrayExpression(expr.right)) {
|
|
return _.map(expr.right.elements, function (elem) {
|
|
return t.expressionStatement(elem);
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
exports.Function = function (node, parent, scope) {
|
|
// only tail recursion can be optimized as for now,
|
|
// so we can skip anonymous functions entirely
|
|
var ownerId = node.id;
|
|
if (!ownerId) return;
|
|
|
|
var argumentsId, thisId, leftId, functionId, params, paramDecls;
|
|
|
|
var state = {
|
|
hasTailRecursion: false,
|
|
needsThis: false,
|
|
needsArguments: false,
|
|
setsArguments: false,
|
|
ownerId: ownerId,
|
|
vars: [],
|
|
|
|
getArgumentsId: function () {
|
|
return argumentsId = argumentsId || scope.generateUidIdentifier("arguments");
|
|
},
|
|
|
|
getThisId: function () {
|
|
return thisId = thisId || scope.generateUidIdentifier("this");
|
|
},
|
|
|
|
getLeftId: function () {
|
|
return leftId = leftId || scope.generateUidIdentifier("left");
|
|
},
|
|
|
|
getFunctionId: function () {
|
|
return functionId = functionId || scope.generateUidIdentifier("function");
|
|
},
|
|
|
|
getParams: function () {
|
|
if (!params) {
|
|
params = node.params;
|
|
paramDecls = [];
|
|
for (var i = 0; i < params.length; i++) {
|
|
var param = params[i];
|
|
if (!param._isDefaultPlaceholder) {
|
|
paramDecls.push(t.variableDeclarator(
|
|
param,
|
|
params[i] = scope.generateUidIdentifier("x")
|
|
));
|
|
}
|
|
}
|
|
}
|
|
return params;
|
|
}
|
|
};
|
|
|
|
// traverse the function and look for tail recursion
|
|
scope.traverse(node, firstPass, state);
|
|
|
|
if (!state.hasTailRecursion) return;
|
|
|
|
scope.traverse(node, secondPass, state);
|
|
|
|
if (!state.needsThis || !state.needsArguments) {
|
|
scope.traverse(node, thirdPass, state);
|
|
}
|
|
|
|
var body = t.ensureBlock(node).body;
|
|
|
|
if (state.vars.length > 0) {
|
|
body.unshift(t.expressionStatement(
|
|
_(state.vars)
|
|
.map(function (decl) {
|
|
return decl.declarations;
|
|
})
|
|
.flatten()
|
|
.reduceRight(function (expr, decl) {
|
|
return t.assignmentExpression("=", decl.id, expr);
|
|
}, t.identifier("undefined"))
|
|
));
|
|
}
|
|
|
|
if (paramDecls.length > 0) {
|
|
body.unshift(t.variableDeclaration("var", paramDecls));
|
|
}
|
|
|
|
node.body = util.template("tail-call-body", {
|
|
THIS_ID: thisId,
|
|
ARGUMENTS_ID: argumentsId,
|
|
FUNCTION_ID: state.getFunctionId(),
|
|
BLOCK: node.body
|
|
});
|
|
|
|
var topVars = [];
|
|
|
|
if (state.needsThis) {
|
|
topVars.push(t.variableDeclarator(state.getThisId(), t.thisExpression()));
|
|
}
|
|
|
|
if (state.needsArguments || state.setsArguments) {
|
|
var decl = t.variableDeclarator(state.getArgumentsId());
|
|
if (state.needsArguments) {
|
|
decl.init = t.identifier("arguments");
|
|
}
|
|
topVars.push(decl);
|
|
}
|
|
|
|
if (leftId) {
|
|
topVars.push(t.variableDeclarator(leftId));
|
|
}
|
|
|
|
if (topVars.length > 0) {
|
|
node.body.body.unshift(t.variableDeclaration("var", topVars));
|
|
}
|
|
};
|