import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Query the DefinitionProvider for the list of definitions that
 * correspond to a given qualified name subtree.  Return null if
 * DefinitionProvider does not contain an entry for a given name,
 * one or more of the values returned by getDeclarations is not
 * callable, or the "name" node is not a GETPROP or NAME.
 *
 * @param definitionProvider The name reference graph
 * @param name Query node
 * @return non-empty definition list or null
 */
private static Collection<Definition> getCallableDefinitions(
    DefinitionProvider definitionProvider, Node name) {
  List<Definition> result = Lists.newArrayList();

  if (!NodeUtil.isGetProp(name) && !NodeUtil.isName(name)) {
    return null;
  }

  Collection<Definition> decls =
      definitionProvider.getDefinitionsReferencedAt(name);
  if (decls == null) {
    return null;
  }

  for (Definition current : decls) {
    Node rValue = current.getRValue();
    if ((rValue != null) && NodeUtil.isFunction(rValue)) {
      result.add(current);
    } else {
      return null;
    }
  }

  return result;
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
@Override
public Collection<Definition> getDefinitionsReferencedAt(Node useSite) {
  List<Name> nameRefs = getReferencesAt(useSite);
  if (nameRefs.isEmpty()) {
    return null;
  }

  List<Definition> result = Lists.newArrayList();
  for (Name nameRef : nameRefs) {
    List<Definition> decls = nameRef.getDeclarations();
    if (!decls.isEmpty()) {
      result.addAll(decls);
    } else {
      result.add(new UnknownDefinition(useSite));
    }
  }

  if (!result.isEmpty()) {
    return result;
  } else {
    return null;
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Rewrites object method call sites as calls to global functions
 * that take "this" as their first argument.
 *
 * Before:
 *   o.foo(a, b, c)
 *
 * After:
 *   foo(o, a, b, c)
 */
private void rewriteCallSites(SimpleDefinitionFinder defFinder,
                              Definition definition,
                              String newMethodName) {
  Collection<UseSite> useSites = defFinder.getUseSites(definition);
  for (UseSite site : useSites) {
    Node node = site.node;
    Node parent = node.getParent();

    Node objectNode = node.getFirstChild();
    node.removeChild(objectNode);
    parent.replaceChild(node, objectNode);
    parent.addChildToFront(Node.newString(Token.NAME, newMethodName));
    compiler.reportCodeChange();
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Removes any optional parameters if no callers specifies it as an argument.
 * @param name The name of the function to optimize. 
 * @param edges All the references to this name.
 */
private void tryEliminateOptionalArgs(Name name,
    List<DiGraphEdge<Name, Reference>> edges) {
  
  // Count the maximum number of arguments passed into this function all
  // all points of the program.
  int maxArgs = -1;

  for (DiGraphEdge<Name, Reference> refEdge : edges) {
    Reference ref = refEdge.getValue();
    Node call = ref.parent;

    if (isCallSite(ref)) {
      int numArgs = call.getChildCount() - 1;
      if (numArgs > maxArgs) {
        maxArgs = numArgs;
      }
    } // else this is a definition or a dereference, ignore it.
  }

  for (Definition definition : name.getDeclarations()) {
    eliminateParamsAfter(definition.getRValue(), maxArgs);
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Determines if the type of the value of the rhs expression can
 * be a function node.
 */
private static boolean definitionTypeContainsFunctionType(Definition def) {
  Node rhs = def.getRValue();
  if (rhs == null) {
    return true;
  }

  switch (rhs.getType()) {
    case Token.ASSIGN:
    case Token.AND:
    case Token.CALL:
    case Token.GETPROP:
    case Token.GETELEM:
    case Token.FUNCTION:
    case Token.HOOK:
    case Token.NAME:
    case Token.NEW:
    case Token.OR:
      return true;
    default:
      return false;
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
@Override
public void visit(NodeTraversal traversal, Node node, Node parent) {
  if (!NodeUtil.isCall(node) && !NodeUtil.isNew(node)) {
    return;
  }

  Collection<Definition> definitions =
      defFinder.getDefinitionsReferencedAt(node.getFirstChild());
  if (definitions == null) {
    return;
  }

  for (Definition def : definitions) {
    Node lValue = def.getLValue();
    Preconditions.checkNotNull(lValue);
    if (!noSideEffectFunctionNames.contains(lValue) &&
        definitionTypeContainsFunctionType(def)) {
      return;
    }
  }

  node.setIsNoSideEffectsCall();
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
@Override
public Collection<Definition> getDefinitionsReferencedAt(Node useSite) {
  if (definitionSiteMap.containsKey(useSite)) {
    return null;
  }

  if (NodeUtil.isGetProp(useSite)) {
    String propName = useSite.getLastChild().getString();
    if (propName.equals("apply") || propName.equals("call")) {
      useSite = useSite.getFirstChild();
    }
  }

  String name = getSimplifiedName(useSite);
  if (name != null) {
    Collection<Definition> defs = nameDefinitionMultimap.get(name);
    if (!defs.isEmpty()) {
      return defs;
    } else {
      return null;
    }
  } else {
    return null;
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
@Override
public void visit(NodeTraversal traversal, Node node, Node parent) {

  Collection<Definition> defs = getDefinitionsReferencedAt(node);
  if (defs == null) {
    return;
  }

  Definition first = defs.iterator().next();

  String name = getSimplifiedName(first.getLValue());
  Preconditions.checkNotNull(name);
  nameUseSiteMultimap.put(
      name,
      new UseSite(node, traversal.getModule()));
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
public void visit(NodeTraversal traversal, Node node, Node parent) {
  Collection<Definition> defs =
      passUnderTest.getDefinitionsReferencedAt(node);
  if (defs != null) {
    StringBuffer sb = new StringBuffer();
    sb.append("USE ");
    sb.append(Token.name(node.getType()));
    sb.append(" ");
    sb.append(node.getQualifiedName());
    sb.append(" -> ");
    Multiset<String> defstrs = TreeMultiset.create();
    for (Definition def : defs) {
      Node rValue = def.getRValue();
      if (rValue != null) {
        defstrs.add(Token.name(rValue.getType()));
      } else {
        defstrs.add("<null>");
      }
    }

    sb.append(defstrs.toString());
    found.add(sb.toString());
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Queries the definition provider for the definitions that could be the
 * targets of the given callsite node.
 * 
 * This is complicated by the fact that NameReferenceGraph and
 * SimpleDefinitionProvider (the two definition providers we currently
 * use) differ on the types of target nodes they will analyze.
 */
private Collection<Definition> lookupDefinitionsForTargetsOfCall(
    Node callsite, DefinitionProvider definitionProvider) {
  Preconditions.checkArgument(callsite.getType() == Token.CALL
      || callsite.getType() == Token.NEW);
  
  Node targetExpression = callsite.getFirstChild();
  
  // NameReferenceGraph throws an exception unless the node is
  // a GETPROP or a NAME
  if (!useNameReferenceGraph 
      || (NodeUtil.isGetProp(targetExpression)
      ||  NodeUtil.isName(targetExpression))) {
    
    Collection<Definition> definitions = 
      definitionProvider.getDefinitionsReferencedAt(targetExpression);
    
    if (definitions != null && !definitions.isEmpty()) {
      return definitions;
    }
  }
  
  return null;
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
@Override
public Collection<Definition> getDefinitionsReferencedAt(Node useSite) {
  List<Name> nameRefs = getReferencesAt(useSite);
  if (nameRefs.isEmpty()) {
    return null;
  }

  List<Definition> result = Lists.newArrayList();
  for (Name nameRef : nameRefs) {
    List<Definition> decls = nameRef.getDeclarations();
    if (!decls.isEmpty()) {
      result.addAll(decls);
    }
  }

  if (!result.isEmpty()) {
    return result;
  } else {
    return null;
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Rewrites object method call sites as calls to global functions
 * that take "this" as their first argument.
 *
 * Before:
 *   o.foo(a, b, c)
 *
 * After:
 *   foo(o, a, b, c)
 */
private void rewriteCallSites(SimpleDefinitionFinder defFinder,
                              Definition definition,
                              String newMethodName) {
  Collection<UseSite> useSites = defFinder.getUseSites(definition);
  for (UseSite site : useSites) {
    Node node = site.node;
    Node parent = node.getParent();

    Node objectNode = node.getFirstChild();
    node.removeChild(objectNode);
    parent.replaceChild(node, objectNode);
    parent.addChildToFront(
        Node.newString(Token.NAME, newMethodName)
            .copyInformationFrom(node));
    compiler.reportCodeChange();

    if (specializationState != null) {
      specializationState.reportSpecializedFunctionContainingNode(parent);
    }
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Uses the provided {@link SimpleDefinitionFinder} to determine
 * which functions are aliased or exposed to .call() or .apply().
 */
public void analyze(SimpleDefinitionFinder finder) {
  Preconditions.checkState(aliasedFunctions == null);
  
  aliasedFunctions = Sets.newHashSet();
  functionsExposedToCallOrApply = Sets.newHashSet();
  
  for (DefinitionSite definitionSite : finder.getDefinitionSites()) {
    Definition definition = definitionSite.definition;
    
    if (!definition.isExtern()) {
      Node rValue = definition.getRValue();
      
      if (rValue != null && NodeUtil.isFunction(rValue)) {
        // rValue is a Token.FUNCTION from a definition
        
        for (UseSite useSite : finder.getUseSites(definition)) {
          updateFunctionForUse(rValue, useSite.node);
        }          
      }     
    }
  }   
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Removes any optional parameters if no callers specifies it as an argument.
 * @param name The name of the function to optimize.
 * @param edges All the references to this name.
 */
private void tryEliminateOptionalArgs(Name name,
    List<DiGraphEdge<Name, Reference>> edges) {

  // Count the maximum number of arguments passed into this function all
  // all points of the program.
  int maxArgs = -1;

  for (DiGraphEdge<Name, Reference> refEdge : edges) {
    Reference ref = refEdge.getValue();
    Node call = ref.parent;

    if (isCallSite(ref)) {
      int numArgs = call.getChildCount() - 1;
      if (numArgs > maxArgs) {
        maxArgs = numArgs;
      }
    } // else this is a definition or a dereference, ignore it.
  }

  for (Definition definition : name.getDeclarations()) {
    eliminateParamsAfter(definition.getRValue(), maxArgs);
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Queries the definition provider for the definitions that could be the
 * targets of the given callsite node.
 *
 * This is complicated by the fact that NameReferenceGraph and
 * SimpleDefinitionProvider (the two definition providers we currently
 * use) differ on the types of target nodes they will analyze.
 */
private Collection<Definition> lookupDefinitionsForTargetsOfCall(
    Node callsite, DefinitionProvider definitionProvider) {
  Preconditions.checkArgument(callsite.isCall()
      || callsite.isNew());

  Node targetExpression = callsite.getFirstChild();

  // NameReferenceGraph throws an exception unless the node is
  // a GETPROP or a NAME
  if (!useNameReferenceGraph
      || (targetExpression.isGetProp()
      ||  targetExpression.isName())) {

    Collection<Definition> definitions =
      definitionProvider.getDefinitionsReferencedAt(targetExpression);

    if (definitions != null && !definitions.isEmpty()) {
      return definitions;
    }
  }

  return null;
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * 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;
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * 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();
    }
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * @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);
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Rewrites object method call sites as calls to global functions
 * that take "this" as their first argument.
 *
 * Before:
 *   o.foo(a, b, c)
 *
 * After:
 *   foo(o, a, b, c)
 */
private void rewriteCallSites(SimpleDefinitionFinder defFinder,
                              Definition definition,
                              String newMethodName) {
  Collection<UseSite> useSites = defFinder.getUseSites(definition);
  for (UseSite site : useSites) {
    Node node = site.node;
    Node parent = node.getParent();

    Node objectNode = node.getFirstChild();
    node.removeChild(objectNode);
    parent.replaceChild(node, objectNode);
    parent.addChildToFront(IR.name(newMethodName).srcref(node));
    Preconditions.checkState(parent.isCall());
    parent.putBooleanProp(Node.FREE_CALL, true);
    compiler.reportCodeChange();

    if (specializationState != null) {
      specializationState.reportSpecializedFunctionContainingNode(parent);
    }
  }
}
 

import com.google.javascript.jscomp.DefinitionsRemover.Definition; //导入依赖的package包/类
/**
 * Uses the provided {@link SimpleDefinitionFinder} to determine
 * which functions are aliased or exposed to .call() or .apply().
 */
public void analyze(SimpleDefinitionFinder finder) {
  Preconditions.checkState(aliasedFunctions == null);

  aliasedFunctions = Sets.newHashSet();
  functionsExposedToCallOrApply = Sets.newHashSet();

  for (DefinitionSite definitionSite : finder.getDefinitionSites()) {
    Definition definition = definitionSite.definition;

    if (!definition.isExtern()) {
      Node rValue = definition.getRValue();

      if (rValue != null && rValue.isFunction()) {
        // rValue is a Token.FUNCTION from a definition

        for (UseSite useSite : finder.getUseSites(definition)) {
          updateFunctionForUse(rValue, useSite.node);
        }
      }
    }
  }
}