private void scanRoot(Node n, Scope parent) {
if (n.getType() == Token.FUNCTION) {
sourceName = (String) n.getProp(Node.SOURCENAME_PROP);
final Node fnNameNode = n.getFirstChild();
final Node args = fnNameNode.getNext();
final Node body = args.getNext();
// Bleed the function name into the scope, if it hasn't
// been declared in the outer scope.
String fnName = fnNameNode.getString();
if (!fnName.isEmpty() && NodeUtil.isFunctionExpression(n)) {
declareVar(fnName, fnNameNode, n, null, null, n);
}
// Args: Declare function variables
Preconditions.checkState(args.getType() == Token.LP);
for (Node a = args.getFirstChild(); a != null; a = a.getNext()) {
Preconditions.checkState(a.getType() == Token.NAME);
declareVar(a.getString(), a, args, n, null, n);
}
// Body
scanVars(body, n);
} else {
// It's the global block
Preconditions.checkState(scope.getParent() == null);
scanVars(n, null);
}
}
public void findNamedFunctions(NodeTraversal t, Node n, Node parent) {
if (!NodeUtil.isStatement(n)) {
// There aren't any interesting functions here.
return;
}
switch (n.getType()) {
// Functions expressions in the form of:
// var fooFn = function(x) { return ... }
case Token.VAR:
Preconditions.checkState(n.hasOneChild());
Node nameNode = n.getFirstChild();
if (nameNode.isName()
&& nameNode.hasChildren()
&& nameNode.getFirstChild().isFunction()) {
maybeAddFunction(new FunctionVar(n), t.getModule());
}
break;
// Named functions
// function Foo(x) { return ... }
case Token.FUNCTION:
Preconditions.checkState(NodeUtil.isStatementBlock(parent) || parent.isLabel());
if (!NodeUtil.isFunctionExpression(n)) {
Function fn = new NamedFunction(n);
maybeAddFunction(fn, t.getModule());
}
break;
}
}
/** Traverses a function. */
private void traverseFunction(Node n, Node parent) {
Preconditions.checkState(n.getChildCount() == 3);
Preconditions.checkState(n.isFunction());
final Node fnName = n.getFirstChild();
boolean isFunctionExpression = (parent != null) && NodeUtil.isFunctionExpression(n);
if (!isFunctionExpression) {
// Functions declarations are in the scope containing the declaration.
traverseBranch(fnName, n);
}
curNode = n;
pushScope(n);
if (isFunctionExpression) {
// Function expression names are only accessible within the function
// scope.
traverseBranch(fnName, n);
}
final Node args = fnName.getNext();
final Node body = args.getNext();
// Args
traverseBranch(args, n);
// Body
// ES6 "arrow" function may not have a block as a body.
traverseBranch(body, n);
popScope();
}
private void scanRoot(Node n) {
if (n.isFunction()) {
if (inputId == null) {
inputId = NodeUtil.getInputId(n);
// TODO(johnlenz): inputId maybe null if the FUNCTION node is detached
// from the AST.
// Is it meaningful to build a scope for detached FUNCTION node?
}
final Node fnNameNode = n.getFirstChild();
final Node args = fnNameNode.getNext();
final Node body = args.getNext();
// Bleed the function name into the scope, if it hasn't
// been declared in the outer scope.
String fnName = fnNameNode.getString();
if (!fnName.isEmpty() && NodeUtil.isFunctionExpression(n)) {
declareVar(fnNameNode);
}
// Args: Declare function variables
Preconditions.checkState(args.isParamList());
for (Node a = args.getFirstChild(); a != null; a = a.getNext()) {
Preconditions.checkState(a.isName());
declareVar(a);
}
// Body
scanVars(body);
} else {
// It's the global block
Preconditions.checkState(scope.getParent() == null);
scanVars(n);
}
}
/** Scans and gather variables declarations under a Node */
private void scanVars(Node n, Node parent) {
switch (n.getType()) {
case Token.VAR:
// Declare all variables. e.g. var x = 1, y, z;
for (Node child = n.getFirstChild(); child != null; ) {
Node next = child.getNext();
Preconditions.checkState(child.getType() == Token.NAME);
String name = child.getString();
declareVar(name, child, n, parent, null, n);
child = next;
}
return;
case Token.FUNCTION:
if (NodeUtil.isFunctionExpression(n)) {
return;
}
String fnName = n.getFirstChild().getString();
if (fnName.isEmpty()) {
// This is invalid, but allow it so the checks can catch it.
return;
}
declareVar(fnName, n.getFirstChild(), n, parent, null, n);
return; // should not examine function's children
case Token.CATCH:
Preconditions.checkState(n.getChildCount() == 2);
Preconditions.checkState(n.getFirstChild().getType() == Token.NAME);
// the first child is the catch var and the third child
// is the code block
final Node var = n.getFirstChild();
final Node block = var.getNext();
declareVar(var.getString(), var, n, parent, null, n);
scanVars(block, n);
return; // only one child to scan
case Token.SCRIPT:
sourceName = (String) n.getProp(Node.SOURCENAME_PROP);
break;
}
// Variables can only occur in statement-level nodes, so
// we only need to traverse children in a couple special cases.
if (NodeUtil.isControlStructure(n) || NodeUtil.isStatementBlock(n)) {
for (Node child = n.getFirstChild(); child != null; ) {
Node next = child.getNext();
scanVars(child, n);
child = next;
}
}
}
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
if (!n.isName()) {
return;
}
String name = n.getString();
// Ignore anonymous functions
if (name.length() == 0) {
return;
}
// Is this local or Global?
// Bleeding functions should be treated as part of their outer
// scope, because IE has bugs in how it handles bleeding
// functions.
Scope.Var var = t.getScope().getVar(name);
boolean local =
(var != null)
&& var.isLocal()
&& (!var.scope.getParent().isGlobal() || !var.isBleedingFunction());
// Are we renaming global variables?
if (!local && localRenamingOnly) {
reservedNames.add(name);
return;
}
// Are we renaming function expression names?
if (preserveFunctionExpressionNames
&& var != null
&& NodeUtil.isFunctionExpression(var.getParentNode())) {
reservedNames.add(name);
return;
}
// Check if we can rename this.
if (!okToRenameVar(name, local)) {
if (local) {
// Blindly de-uniquify for the Prototype library for issue 103.
String newName = MakeDeclaredNamesUnique.ContextualRenameInverter.getOrginalName(name);
if (!newName.equals(name)) {
n.setString(newName);
}
}
return;
}
if (isExternsPass_) {
// Keep track of extern globals.
if (!local) {
externNames.add(name);
}
return;
}
if (pseudoNameMap != null) {
recordPseudoName(n);
}
if (local) {
// Local var: assign a new name
String tempName = LOCAL_VAR_PREFIX + getLocalVarIndex(var);
incCount(tempName);
localNameNodes.add(n);
n.setString(tempName);
} else if (var != null) { // Not an extern
// If it's global, increment global count
incCount(name);
globalNameNodes.add(n);
}
}
/**
* 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();
}
}
}
