/** If this is an assign to a variable or its property, return it. Otherwise, return null. */
static Assign maybeCreateAssign(Node assignNode) {
Preconditions.checkState(NodeUtil.isAssignmentOp(assignNode));
// Skip one level of GETPROPs or GETELEMs.
//
// Don't skip more than one level, because then we get into
// situations where assigns to properties of properties will always
// trigger side-effects, and the variable they're on cannot be removed.
boolean isPropAssign = false;
Node current = assignNode.getFirstChild();
if (NodeUtil.isGet(current)) {
current = current.getFirstChild();
isPropAssign = true;
if (current.getType() == Token.GETPROP
&& current.getLastChild().getString().equals("prototype")) {
// Prototype properties sets should be considered like normal
// property sets.
current = current.getFirstChild();
}
}
if (current.getType() == Token.NAME) {
return new Assign(assignNode, current, isPropAssign);
}
return null;
}
/**
* Returns the nth argument node given a usage site for a direct function call or for a
* func.call() node.
*/
private static Node getArgumentForCallOrNewOrDotCall(UseSite site, final int argIndex) {
int adjustedArgIndex = argIndex;
Node parent = site.node.getParent();
if (NodeUtil.isFunctionObjectCall(parent)) {
adjustedArgIndex++;
}
return NodeUtil.getArgumentForCallOrNew(parent, adjustedArgIndex);
}
Assign(Node assignNode, Node nameNode, boolean isPropertyAssign) {
Preconditions.checkState(NodeUtil.isAssignmentOp(assignNode));
this.assignNode = assignNode;
this.nameNode = nameNode;
this.isPropertyAssign = isPropertyAssign;
this.mayHaveSecondarySideEffects =
assignNode.getParent().getType() != Token.EXPR_RESULT
|| NodeUtil.mayHaveSideEffects(assignNode.getFirstChild())
|| NodeUtil.mayHaveSideEffects(assignNode.getLastChild());
}
/**
* Removes unreferenced arguments from a function declaration and when possible the function's
* callSites.
*
* @param fnScope The scope inside the function
*/
private void removeUnreferencedFunctionArgs(Scope fnScope) {
// TODO(johnlenz): Update type registry for function signature changes.
Node function = fnScope.getRootNode();
Preconditions.checkState(function.getType() == Token.FUNCTION);
if (NodeUtil.isGetOrSetKey(function.getParent())) {
// The parameters object literal setters can not be removed.
return;
}
Node argList = getFunctionArgList(function);
boolean modifyCallers = modifyCallSites && callSiteOptimizer.canModifyCallers(function);
if (!modifyCallers) {
// Strip unreferenced args off the end of the function declaration.
Node lastArg;
while ((lastArg = argList.getLastChild()) != null) {
Var var = fnScope.getVar(lastArg.getString());
if (!referenced.contains(var)) {
Preconditions.checkNotNull(var == null);
argList.removeChild(lastArg);
compiler.reportCodeChange();
} else {
break;
}
}
} else {
callSiteOptimizer.optimize(fnScope, referenced);
}
}
/**
* @return Whether the definitionSite represents a function whose call signature can be
* modified.
*/
private boolean canChangeSignature(Node function) {
Definition definition = getFunctionDefinition(function);
CodingConvention convention = compiler.getCodingConvention();
Preconditions.checkState(!definition.isExtern());
Collection<UseSite> useSites = defFinder.getUseSites(definition);
for (UseSite site : useSites) {
Node parent = site.node.getParent();
// This was a use site removed by something else before we run.
// 1. By another pass before us which means the definition graph is
// no updated properly.
// 2. By the continuations algorithm above.
if (parent == null) {
continue; // Ignore it.
}
// Ignore references within goog.inherits calls.
if (NodeUtil.isCall(parent) && convention.getClassesDefinedByCall(parent) != null) {
continue;
}
// Accessing the property directly prevents rewrite.
if (!SimpleDefinitionFinder.isCallOrNewSite(site)) {
if (!(NodeUtil.isGetProp(parent) && NodeUtil.isFunctionObjectCall(parent.getParent()))) {
return false;
}
}
if (NodeUtil.isFunctionObjectApply(parent)) {
return false;
}
// TODO(johnlenz): support specialization
// Multiple definitions prevent rewrite.
// Attempt to validate the state of the simple definition finder.
Node nameNode = site.node;
Collection<Definition> singleSiteDefinitions =
defFinder.getDefinitionsReferencedAt(nameNode);
Preconditions.checkState(singleSiteDefinitions.size() == 1);
Preconditions.checkState(singleSiteDefinitions.contains(definition));
}
return true;
}
void apply() {
if (NodeUtil.isFunctionDeclaration(node)) {
traverseFunction(node, scope);
} else {
for (Node child = node.getFirstChild(); child != null; child = child.getNext()) {
traverseNode(child, node, scope);
}
}
}
/**
* Look at all the property assigns to all variables. These may or may not count as references.
* For example, <code>
* var x = {};
* x.foo = 3; // not a reference.
* var y = foo();
* y.foo = 3; // is a reference.
* </code> Interpreting assigments could mark a variable as referenced that wasn't referenced
* before, in order to keep it alive. Because we find references by lazily traversing subtrees,
* marking a variable as referenced could trigger new traversals of new subtrees, which could find
* new references.
*
* <p>Therefore, this interpretation needs to be run to a fixed point.
*/
private void interpretAssigns() {
boolean changes = false;
do {
changes = false;
// We can't use traditional iterators and iterables for this list,
// because our lazily-evaluated continuations will modify it while
// we traverse it.
for (int current = 0; current < maybeUnreferenced.size(); current++) {
Var var = maybeUnreferenced.get(current);
if (referenced.contains(var)) {
maybeUnreferenced.remove(current);
current--;
} else {
boolean assignedToUnknownValue = false;
boolean hasPropertyAssign = false;
if (var.getParentNode().getType() == Token.VAR
&& !NodeUtil.isForIn(var.getParentNode().getParent())) {
Node value = var.getInitialValue();
assignedToUnknownValue = value != null && !NodeUtil.isLiteralValue(value, true);
} else {
// This was initialized to a function arg or a catch param
// or a for...in variable.
assignedToUnknownValue = true;
}
for (Assign assign : assignsByVar.get(var)) {
if (assign.isPropertyAssign) {
hasPropertyAssign = true;
} else if (!NodeUtil.isLiteralValue(assign.assignNode.getLastChild(), true)) {
assignedToUnknownValue = true;
}
}
if (assignedToUnknownValue && hasPropertyAssign) {
changes = markReferencedVar(var) || changes;
maybeUnreferenced.remove(current);
current--;
}
}
}
} while (changes);
}
/** Remove all the following parameters without side-effects */
private void tryRemoveAllFollowingArgs(Node function, final int argIndex) {
Definition definition = getFunctionDefinition(function);
for (UseSite site : defFinder.getUseSites(definition)) {
if (!isModifiableCallSite(site)) {
continue;
}
Node arg = getArgumentForCallOrNewOrDotCall(site, argIndex + 1);
while (arg != null) {
if (!NodeUtil.mayHaveSideEffects(arg)) {
toRemove.add(arg);
}
arg = arg.getNext();
}
}
}
/**
* Remove all references to a parameter if possible otherwise simplify the side-effect free
* parameters.
*/
private void tryRemoveArgFromCallSites(Node function, int argIndex, boolean canModifyAllSites) {
Definition definition = getFunctionDefinition(function);
for (UseSite site : defFinder.getUseSites(definition)) {
if (isModifiableCallSite(site)) {
Node arg = getArgumentForCallOrNewOrDotCall(site, argIndex);
if (arg != null) {
Node argParent = arg.getParent();
// Even if we can't change the signature in general we can always
// remove an unused value off the end of the parameter list.
if (canModifyAllSites
|| (arg.getNext() == null && !NodeUtil.mayHaveSideEffects(arg, compiler))) {
toRemove.add(arg);
} else {
// replace the node in the arg with 0
if (!NodeUtil.mayHaveSideEffects(arg, compiler)
&& (arg.getType() != Token.NUMBER || arg.getDouble() != 0)) {
toReplaceWithZero.add(arg);
}
}
}
}
}
}
/**
* Remove all references to a parameter, otherwise simplify the known references.
*
* @return Whether all the references were removed.
*/
private boolean canRemoveArgFromCallSites(Node function, int argIndex) {
Definition definition = getFunctionDefinition(function);
// Check all the call sites.
for (UseSite site : defFinder.getUseSites(definition)) {
if (isModifiableCallSite(site)) {
Node arg = getArgumentForCallOrNewOrDotCall(site, argIndex);
// TODO(johnlenz): try to remove parameters with side-effects by
// decomposing the call expression.
if (arg != null && NodeUtil.mayHaveSideEffects(arg, compiler)) {
return false;
}
} else {
return false;
}
}
return true;
}
/**
* @param function
* @return Whether the callers to this function can be modified in any way.
*/
boolean canModifyCallers(Node function) {
if (NodeUtil.isVarArgsFunction(function)) {
return false;
}
DefinitionSite defSite = defFinder.getDefinitionForFunction(function);
if (defSite == null) {
return false;
}
Definition definition = defSite.definition;
// Be conservative, don't try to optimize any declaration that isn't as
// simple function declaration or assignment.
if (!SimpleDefinitionFinder.isSimpleFunctionDeclaration(function)) {
return false;
}
return defFinder.canModifyDefinition(definition);
}
/**
* Removes any vars in the scope that were not referenced. Removes any assignments to those
* variables as well.
*/
private void removeUnreferencedVars() {
CodingConvention convention = codingConvention;
for (Iterator<Var> it = maybeUnreferenced.iterator(); it.hasNext(); ) {
Var var = it.next();
// Remove calls to inheritance-defining functions where the unreferenced
// class is the subclass.
for (Node exprCallNode : inheritsCalls.get(var)) {
NodeUtil.removeChild(exprCallNode.getParent(), exprCallNode);
compiler.reportCodeChange();
}
// Regardless of what happens to the original declaration,
// we need to remove all assigns, because they may contain references
// to other unreferenced variables.
removeAllAssigns(var);
compiler.addToDebugLog("Unreferenced var: " + var.name);
Node nameNode = var.nameNode;
Node toRemove = nameNode.getParent();
Node parent = toRemove.getParent();
Preconditions.checkState(
toRemove.getType() == Token.VAR
|| toRemove.getType() == Token.FUNCTION
|| toRemove.getType() == Token.LP && parent.getType() == Token.FUNCTION,
"We should only declare vars and functions and function args");
if (toRemove.getType() == Token.LP && parent.getType() == Token.FUNCTION) {
// Don't remove function arguments here. That's a special case
// that's taken care of in removeUnreferencedFunctionArgs.
} else if (NodeUtil.isFunctionExpression(toRemove)) {
if (!preserveFunctionExpressionNames) {
toRemove.getFirstChild().setString("");
compiler.reportCodeChange();
}
// Don't remove bleeding functions.
} else if (parent != null && parent.getType() == Token.FOR && parent.getChildCount() < 4) {
// foreach iterations have 3 children. Leave them alone.
} else if (toRemove.getType() == Token.VAR
&& nameNode.hasChildren()
&& NodeUtil.mayHaveSideEffects(nameNode.getFirstChild())) {
// If this is a single var declaration, we can at least remove the
// declaration itself and just leave the value, e.g.,
// var a = foo(); => foo();
if (toRemove.getChildCount() == 1) {
parent.replaceChild(toRemove, new Node(Token.EXPR_RESULT, nameNode.removeFirstChild()));
compiler.reportCodeChange();
}
} else if (toRemove.getType() == Token.VAR && toRemove.getChildCount() > 1) {
// For var declarations with multiple names (i.e. var a, b, c),
// only remove the unreferenced name
toRemove.removeChild(nameNode);
compiler.reportCodeChange();
} else if (parent != null) {
NodeUtil.removeChild(parent, toRemove);
compiler.reportCodeChange();
}
}
}
/**
* @param site The site to inspect
* @return Whether the call site is suitable for modification
*/
private static boolean isModifiableCallSite(UseSite site) {
return SimpleDefinitionFinder.isCallOrNewSite(site)
&& !NodeUtil.isFunctionObjectApply(site.node.getParent());
}
/**
* Traverses everything in the current scope and marks variables that are referenced.
*
* <p>During traversal, we identify subtrees that will only be referenced if their enclosing
* variables are referenced. Instead of traversing those subtrees, we create a continuation for
* them, and traverse them lazily.
*/
private void traverseNode(Node n, Node parent, Scope scope) {
int type = n.getType();
Var var = null;
switch (type) {
case Token.FUNCTION:
// If this function is a removable var, then create a continuation
// for it instead of traversing immediately.
if (NodeUtil.isFunctionDeclaration(n)) {
var = scope.getVar(n.getFirstChild().getString());
}
if (var != null && isRemovableVar(var)) {
continuations.put(var, new Continuation(n, scope));
} else {
traverseFunction(n, scope);
}
return;
case Token.ASSIGN:
Assign maybeAssign = Assign.maybeCreateAssign(n);
if (maybeAssign != null) {
// Put this in the assign map. It might count as a reference,
// but we won't know that until we have an index of all assigns.
var = scope.getVar(maybeAssign.nameNode.getString());
if (var != null) {
assignsByVar.put(var, maybeAssign);
assignsByNode.put(maybeAssign.nameNode, maybeAssign);
if (isRemovableVar(var) && !maybeAssign.mayHaveSecondarySideEffects) {
// If the var is unreferenced and performing this assign has
// no secondary side effects, then we can create a continuation
// for it instead of traversing immediately.
continuations.put(var, new Continuation(n, scope));
return;
}
}
}
break;
case Token.CALL:
// Look for calls to inheritance-defining calls (such as goog.inherits).
SubclassRelationship subclassRelationship = codingConvention.getClassesDefinedByCall(n);
if (subclassRelationship != null) {
Var subclassVar = scope.getVar(subclassRelationship.subclassName);
// Don't try to track the inheritance calls for non-globals. It would
// be more correct to only not track when the subclass does not
// reference a constructor, but checking that it is a global is
// easier and mostly the same.
if (subclassVar != null && subclassVar.isGlobal() && !referenced.contains(subclassVar)) {
// Save a reference to the EXPR node.
inheritsCalls.put(subclassVar, parent);
continuations.put(subclassVar, new Continuation(n, scope));
return;
}
}
break;
case Token.NAME:
var = scope.getVar(n.getString());
if (parent.getType() == Token.VAR) {
Node value = n.getFirstChild();
if (value != null
&& var != null
&& isRemovableVar(var)
&& !NodeUtil.mayHaveSideEffects(value)) {
// If the var is unreferenced and creating its value has no side
// effects, then we can create a continuation for it instead
// of traversing immediately.
continuations.put(var, new Continuation(n, scope));
return;
}
} else {
// If arguments is escaped, we just assume the worst and continue
// on all the parameters.
if ("arguments".equals(n.getString()) && scope.isLocal()) {
Node lp = scope.getRootNode().getFirstChild().getNext();
for (Node a = lp.getFirstChild(); a != null; a = a.getNext()) {
markReferencedVar(scope.getVar(a.getString()));
}
}
// All name references that aren't declarations or assigns
// are references to other vars.
if (var != null) {
// If that var hasn't already been marked referenced, then
// start tracking it. If this is an assign, do nothing
// for now.
if (isRemovableVar(var)) {
if (!assignsByNode.containsKey(n)) {
markReferencedVar(var);
}
} else {
markReferencedVar(var);
}
}
}
break;
}
for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
traverseNode(c, n, scope);
}
}