private Node createTemplateParameterNode(int index, JSType type) {
Preconditions.checkState(index >= 0);
Preconditions.checkNotNull(type);
Node n = Node.newNumber(index);
n.setType(TEMPLATE_TYPE_PARAM);
n.setJSType(type);
return n;
}
private void visitObjectWithComputedProperty(Node obj, Node parent) {
Preconditions.checkArgument(obj.isObjectLit());
List<Node> props = new ArrayList<>();
Node currElement = obj.getFirstChild();
while (currElement != null) {
if (currElement.getBooleanProp(Node.COMPUTED_PROP_GETTER)
|| currElement.getBooleanProp(Node.COMPUTED_PROP_SETTER)) {
cannotConvertYet(currElement, "computed getter/setter");
return;
} else if (currElement.isGetterDef() || currElement.isSetterDef()) {
currElement = currElement.getNext();
} else {
Node nextNode = currElement.getNext();
obj.removeChild(currElement);
props.add(currElement);
currElement = nextNode;
}
}
String objName = FRESH_COMP_PROP_VAR + compiler.getUniqueNameIdSupplier().get();
props = Lists.reverse(props);
Node result = IR.name(objName);
for (Node propdef : props) {
if (propdef.isComputedProp()) {
Node propertyExpression = propdef.removeFirstChild();
Node value = propdef.removeFirstChild();
result =
IR.comma(IR.assign(IR.getelem(IR.name(objName), propertyExpression), value), result);
} else {
if (!propdef.hasChildren()) {
Node name = IR.name(propdef.getString()).useSourceInfoIfMissingFrom(propdef);
propdef.addChildToBack(name);
}
Node val = propdef.removeFirstChild();
propdef.setType(Token.STRING);
int type = propdef.isQuotedString() ? Token.GETELEM : Token.GETPROP;
Node access = new Node(type, IR.name(objName), propdef);
result = IR.comma(IR.assign(access, val), result);
}
}
Node statement = obj;
while (!NodeUtil.isStatement(statement)) {
statement = statement.getParent();
}
result.useSourceInfoIfMissingFromForTree(obj);
parent.replaceChild(obj, result);
Node var = IR.var(IR.name(objName), obj);
var.useSourceInfoIfMissingFromForTree(statement);
statement.getParent().addChildBefore(var, statement);
compiler.reportCodeChange();
}
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
// System.out.println(n);
switch (n.getType()) {
case Token.FUNCTION:
Node functionNameNode = n.getFirstChild();
String currFunctionName = functionNameNode.getString();
if (!anonymizedFnNodes.contains(n)) {
if (currFunctionName.length() == 0) {
Set<String> closures = findClosures(n);
// System.out.println("closures" + closures);
n.detachFromParent(); // detach anonymous function from.
// change all references to 'this' in method to $$_self
boolean thisChanged = changeThisTo$$_self(n);
// clone the parameters of modified $$$anonym(originalParams..., closures..) so that
// we can use it for parameters of function call below
Node clonedorigParamNode = n.getChildAtIndex(1).cloneTree();
clonedorigParamNode.setType(Token.LP);
// parent
// give 'n' a name and attach to end
// e.g. function $$anonym(originalParams..., closures..)
String anonymName = "$$anonym" + anonymCount++;
Node funcNameNode = Node.newString(Token.NAME, anonymName);
n.replaceChild(n.getFirstChild(), funcNameNode);
Node parametersNode = n.getChildAtIndex(1);
addParamsToMethod(closures, parametersNode, thisChanged, "$$_self");
root.getFirstChild().addChildrenToBack(n);
// replace original anonymous call to new anonymous function that closes over
// params and then makes a call to our named function
Node newAnonymNode =
createAnonymWithParamCall(closures, anonymName, clonedorigParamNode, thisChanged);
parent.addChildrenToBack(newAnonymNode);
// add to list of anonymized nodes so that we can ignore it on second pass
anonymizedFnNodes.add(newAnonymNode);
compiler.reportCodeChange();
} else { // named function just find closures and add as parameter
// TODO
}
}
}
}
/** Processes trailing default and rest parameters. */
private void visitParamList(Node paramList, Node function) {
Node insertSpot = null;
Node block = function.getLastChild();
for (int i = 0; i < paramList.getChildCount(); i++) {
Node param = paramList.getChildAtIndex(i);
if (param.isDefaultValue()) {
Node nameOrPattern = param.removeFirstChild();
Node defaultValue = param.removeFirstChild();
Node newParam =
nameOrPattern.isName()
? nameOrPattern
: IR.name(DESTRUCTURING_TEMP_VAR + (destructuringVarCounter++));
Node lhs = nameOrPattern.cloneTree();
Node rhs = defaultValueHook(newParam.cloneTree(), defaultValue);
Node newStatement =
nameOrPattern.isName() ? IR.exprResult(IR.assign(lhs, rhs)) : IR.var(lhs, rhs);
newStatement.useSourceInfoIfMissingFromForTree(param);
block.addChildAfter(newStatement, insertSpot);
insertSpot = newStatement;
paramList.replaceChild(param, newParam);
newParam.setOptionalArg(true);
compiler.reportCodeChange();
} else if (param.isRest()) { // rest parameter
param.setType(Token.NAME);
param.setVarArgs(true);
// Transpile to: param = [].slice.call(arguments, i);
Node newArr =
IR.exprResult(
IR.assign(
IR.name(param.getString()),
IR.call(
IR.getprop(
IR.getprop(IR.arraylit(), IR.string("slice")), IR.string("call")),
IR.name("arguments"),
IR.number(i))));
block.addChildAfter(newArr.useSourceInfoIfMissingFromForTree(param), insertSpot);
compiler.reportCodeChange();
} else if (param.isDestructuringPattern()) {
String tempVarName = DESTRUCTURING_TEMP_VAR + (destructuringVarCounter++);
paramList.replaceChild(param, IR.name(tempVarName));
Node newDecl = IR.var(param, IR.name(tempVarName));
block.addChildAfter(newDecl, insertSpot);
insertSpot = newDecl;
}
}
// For now, we are running transpilation before type-checking, so we'll
// need to make sure changes don't invalidate the JSDoc annotations.
// Therefore we keep the parameter list the same length and only initialize
// the values if they are set to undefined.
}
private void varify() {
if (!blockScopedDeclarations.isEmpty()) {
for (Node n : blockScopedDeclarations) {
if (n.isConst()) {
JSDocInfoBuilder builder = JSDocInfoBuilder.maybeCopyFrom(n.getJSDocInfo());
builder.recordConstancy();
JSDocInfo info = builder.build();
n.setJSDocInfo(info);
}
n.setType(Token.VAR);
}
compiler.reportCodeChange();
}
}
/** Processes trailing default and rest parameters. */
private void visitParamList(Node paramList, Node function) {
Node insertSpot = null;
Node block = function.getLastChild();
for (int i = 0; i < paramList.getChildCount(); i++) {
Node param = paramList.getChildAtIndex(i);
if (param.hasChildren()) { // default parameter
param.setOptionalArg(true);
Node defaultValue = param.removeFirstChild();
// Transpile to: param === undefined && (param = defaultValue);
Node name = IR.name(param.getString());
Node undefined = IR.name("undefined");
Node stm =
IR.exprResult(
IR.and(IR.sheq(name, undefined), IR.assign(name.cloneNode(), defaultValue)));
block.addChildAfter(stm.useSourceInfoIfMissingFromForTree(param), insertSpot);
insertSpot = stm;
compiler.reportCodeChange();
} else if (param.isRest()) { // rest parameter
param.setType(Token.NAME);
param.setVarArgs(true);
// Transpile to: param = [].slice.call(arguments, i);
Node newArr =
IR.exprResult(
IR.assign(
IR.name(param.getString()),
IR.call(
IR.getprop(
IR.getprop(IR.arraylit(), IR.string("slice")), IR.string("call")),
IR.name("arguments"),
IR.number(i))));
block.addChildAfter(newArr.useSourceInfoIfMissingFromForTree(param), insertSpot);
compiler.reportCodeChange();
}
}
// For now, we are running transpilation before type-checking, so we'll
// need to make sure changes don't invalidate the JSDoc annotations.
// Therefore we keep the parameter list the same length and only initialize
// the values if they are set to undefined.
}
private Node createTemplateLocalNameNode(int index) {
Preconditions.checkState(index >= 0);
Node n = Node.newNumber(index);
n.setType(TEMPLATE_LOCAL_NAME);
return n;
}
/**
* Expand jQuery.extend (and derivative) calls into direct object assignments Example:
* jQuery.extend(obj1, {prop1: val1, prop2: val2}) -> obj1.prop1 = val1; obj1.prop2 = val2;
*/
private void maybeExpandJqueryExtendCall(Node n) {
Node callTarget = n.getFirstChild();
Node objectToExtend = callTarget.getNext(); // first argument
Node extendArg = objectToExtend.getNext(); // second argument
boolean ensureObjectDefined = true;
if (extendArg == null) {
// Only one argument was specified, so extend jQuery namespace
extendArg = objectToExtend;
objectToExtend = callTarget.getFirstChild();
ensureObjectDefined = false;
} else if (objectToExtend.isGetProp()
&& (objectToExtend.getLastChild().getString().equals("prototype")
|| convention.isPrototypeAlias(objectToExtend))) {
ensureObjectDefined = false;
}
// Check for an empty object literal
if (!extendArg.hasChildren()) {
return;
}
// Since we are expanding jQuery.extend calls into multiple statements,
// encapsulate the new statements in a new block.
Node fncBlock = IR.block().srcref(n);
if (ensureObjectDefined) {
Node assignVal = IR.or(objectToExtend.cloneTree(), IR.objectlit().srcref(n)).srcref(n);
Node assign = IR.assign(objectToExtend.cloneTree(), assignVal).srcref(n);
fncBlock.addChildrenToFront(IR.exprResult(assign).srcref(n));
}
while (extendArg.hasChildren()) {
Node currentProp = extendArg.removeFirstChild();
currentProp.setType(Token.STRING);
Node propValue = currentProp.removeFirstChild();
Node newProp;
if (currentProp.isQuotedString()) {
newProp = IR.getelem(objectToExtend.cloneTree(), currentProp).srcref(currentProp);
} else {
newProp = IR.getprop(objectToExtend.cloneTree(), currentProp).srcref(currentProp);
}
Node assignNode = IR.assign(newProp, propValue).srcref(currentProp);
fncBlock.addChildToBack(IR.exprResult(assignNode).srcref(currentProp));
}
// Check to see if the return value is used. If not, replace the original
// call with new block. Otherwise, wrap the statements in an
// immediately-called anonymous function.
if (n.getParent().isExprResult()) {
Node parent = n.getParent();
parent.getParent().replaceChild(parent, fncBlock);
} else {
Node targetVal;
if ("jQuery.prototype".equals(objectToExtend.getQualifiedName())) {
// When extending the jQuery prototype, return the jQuery namespace.
// This is not commonly used.
targetVal = objectToExtend.removeFirstChild();
} else {
targetVal = objectToExtend.detachFromParent();
}
fncBlock.addChildToBack(IR.returnNode(targetVal).srcref(targetVal));
Node fnc = IR.function(IR.name("").srcref(n), IR.paramList().srcref(n), fncBlock).srcref(n);
// add an explicit "call" statement so that we can maintain
// the same reference for "this"
Node newCallTarget = IR.getprop(fnc, IR.string("call").srcref(n)).srcref(n);
n.replaceChild(callTarget, newCallTarget);
n.putBooleanProp(Node.FREE_CALL, false);
// remove any other pre-existing call arguments
while (newCallTarget.getNext() != null) {
n.removeChildAfter(newCallTarget);
}
n.addChildToBack(IR.thisNode().srcref(n));
}
compiler.reportCodeChange();
}
/** Processes a rest parameter */
private void visitRestParam(Node restParam, Node paramList) {
Node functionBody = paramList.getLastSibling();
restParam.setType(Token.NAME);
restParam.setVarArgs(true);
// Make sure rest parameters are typechecked
JSTypeExpression type = null;
JSDocInfo info = restParam.getJSDocInfo();
String paramName = restParam.getString();
if (info != null) {
type = info.getType();
} else {
JSDocInfo functionInfo = paramList.getParent().getJSDocInfo();
if (functionInfo != null) {
type = functionInfo.getParameterType(paramName);
}
}
if (type != null && type.getRoot().getType() != Token.ELLIPSIS) {
compiler.report(JSError.make(restParam, BAD_REST_PARAMETER_ANNOTATION));
}
if (!functionBody.hasChildren()) {
// If function has no body, we are done!
compiler.reportCodeChange();
return;
}
Node newBlock = IR.block().useSourceInfoFrom(functionBody);
Node name = IR.name(paramName);
Node let = IR.let(name, IR.name(REST_PARAMS)).useSourceInfoIfMissingFromForTree(functionBody);
newBlock.addChildToFront(let);
for (Node child : functionBody.children()) {
newBlock.addChildToBack(child.detachFromParent());
}
if (type != null) {
Node arrayType = IR.string("Array");
Node typeNode = type.getRoot();
Node memberType =
typeNode.getType() == Token.ELLIPSIS
? typeNode.getFirstChild().cloneNode()
: typeNode.cloneNode();
arrayType.addChildToFront(
new Node(Token.BLOCK, memberType).useSourceInfoIfMissingFrom(typeNode));
JSDocInfoBuilder builder = new JSDocInfoBuilder(false);
builder.recordType(
new JSTypeExpression(new Node(Token.BANG, arrayType), restParam.getSourceFileName()));
name.setJSDocInfo(builder.build());
}
int restIndex = paramList.getIndexOfChild(restParam);
Node newArr = IR.var(IR.name(REST_PARAMS), IR.arraylit());
functionBody.addChildToFront(newArr.useSourceInfoIfMissingFromForTree(restParam));
Node init = IR.var(IR.name(REST_INDEX), IR.number(restIndex));
Node cond = IR.lt(IR.name(REST_INDEX), IR.getprop(IR.name("arguments"), IR.string("length")));
Node incr = IR.inc(IR.name(REST_INDEX), false);
Node body =
IR.block(
IR.exprResult(
IR.assign(
IR.getelem(
IR.name(REST_PARAMS), IR.sub(IR.name(REST_INDEX), IR.number(restIndex))),
IR.getelem(IR.name("arguments"), IR.name(REST_INDEX)))));
functionBody.addChildAfter(
IR.forNode(init, cond, incr, body).useSourceInfoIfMissingFromForTree(restParam), newArr);
functionBody.addChildToBack(newBlock);
compiler.reportCodeChange();
// For now, we are running transpilation before type-checking, so we'll
// need to make sure changes don't invalidate the JSDoc annotations.
// Therefore we keep the parameter list the same length and only initialize
// the values if they are set to undefined.
}
private void visitArrayPattern(NodeTraversal t, Node arrayPattern, Node parent) {
Node rhs, nodeToDetach;
if (NodeUtil.isNameDeclaration(parent) && !NodeUtil.isEnhancedFor(parent.getParent())) {
// The array pattern is the only child, because Es6SplitVariableDeclarations
// has already run.
Preconditions.checkState(arrayPattern.getNext() == null);
rhs = arrayPattern.getLastChild();
nodeToDetach = parent;
} else if (parent.isAssign()) {
rhs = arrayPattern.getNext();
nodeToDetach = parent.getParent();
Preconditions.checkState(nodeToDetach.isExprResult());
} else if (parent.isArrayPattern() || parent.isDefaultValue() || parent.isStringKey()) {
// This is a nested array pattern. Don't do anything now; we'll visit it
// after visiting the parent.
return;
} else if (NodeUtil.isEnhancedFor(parent) || NodeUtil.isEnhancedFor(parent.getParent())) {
visitDestructuringPatternInEnhancedFor(arrayPattern);
return;
} else {
Preconditions.checkState(parent.isCatch() || parent.isForOf());
cannotConvertYet(
arrayPattern, "ARRAY_PATTERN that is a child of a " + Token.name(parent.getType()));
return;
}
// Convert 'var [x, y] = rhs' to:
// var temp = rhs;
// var x = temp[0];
// var y = temp[1];
String tempVarName = DESTRUCTURING_TEMP_VAR + (destructuringVarCounter++);
Node tempDecl =
IR.var(IR.name(tempVarName), rhs.detachFromParent())
.useSourceInfoIfMissingFromForTree(arrayPattern);
nodeToDetach.getParent().addChildBefore(tempDecl, nodeToDetach);
int i = 0;
for (Node child = arrayPattern.getFirstChild(), next; child != null; child = next, i++) {
next = child.getNext();
if (child.isEmpty()) {
continue;
}
Node newLHS, newRHS;
if (child.isDefaultValue()) {
Node getElem = IR.getelem(IR.name(tempVarName), IR.number(i));
// [x = defaultValue] = rhs;
// becomes
// var temp = rhs;
// x = (temp[0] === undefined) ? defaultValue : temp[0];
newLHS = child.getFirstChild().detachFromParent();
newRHS = defaultValueHook(getElem, child.getLastChild().detachFromParent());
} else if (child.isRest()) {
newLHS = child.detachFromParent();
newLHS.setType(Token.NAME);
// [].slice.call(temp, i)
newRHS =
IR.call(
IR.getprop(IR.getprop(IR.arraylit(), IR.string("slice")), IR.string("call")),
IR.name(tempVarName),
IR.number(i));
} else {
newLHS = child.detachFromParent();
newRHS = IR.getelem(IR.name(tempVarName), IR.number(i));
}
Node newNode;
if (parent.isAssign()) {
Node assignment = IR.assign(newLHS, newRHS);
newNode = IR.exprResult(assignment);
} else {
newNode = IR.declaration(newLHS, newRHS, parent.getType());
}
newNode.useSourceInfoIfMissingFromForTree(arrayPattern);
nodeToDetach.getParent().addChildBefore(newNode, nodeToDetach);
// Explicitly visit the LHS of the new node since it may be a nested
// destructuring pattern.
visit(t, newLHS, newLHS.getParent());
}
nodeToDetach.detachFromParent();
compiler.reportCodeChange();
}