A couple of refactorings:

* Remove interface that only has one implementation
* Change a method that returned a Collection or null, to just return an empty Collection instead of null.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=176561722

src/com/google/javascript/jscomp/AbstractCompiler.java

@@ -245,7 +245,7 @@ static enum MostRecentTypechecker {
    *     modules.
    * @return A SCRIPT node (never null).
    */
-  abstract Node getNodeForCodeInsertion(JSModule module);
+  abstract Node getNodeForCodeInsertion(@Nullable JSModule module);
 
   /**
    * Only used by passes in the old type checker.

src/com/google/javascript/jscomp/Compiler.java

@@ -2986,7 +2986,7 @@ public Region getSourceRegion(String sourceName, int lineNumber) {
   //------------------------------------------------------------------------
 
   @Override
-  Node getNodeForCodeInsertion(JSModule module) {
+  Node getNodeForCodeInsertion(@Nullable JSModule module) {
     if (module == null) {
       if (inputs.isEmpty()) {
         throw new IllegalStateException("No inputs");

src/com/google/javascript/jscomp/DefinitionUseSiteFinder.java

@@ -21,6 +21,7 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.LinkedHashMultimap;
 import com.google.common.collect.Multimap;
@@ -57,7 +58,7 @@ private static class NameAndUseSite {
   @VisibleForTesting
   Multimap<String, UseSite> getUseSitesByName() {
     // Defensive copy.
-    return LinkedHashMultimap.create(useSitesByName);
+    return ImmutableMultimap.copyOf(useSitesByName);
   }
 
   public DefinitionUseSiteFinder(AbstractCompiler compiler) {
@@ -92,7 +93,7 @@ public void visit(NodeTraversal traversal, Node node, Node parent) {
       }
 
       Collection<Definition> defs = getDefinitionsReferencedAt(node);
-      if (defs == null) {
+      if (defs.isEmpty()) {
         return;
       }
 

src/com/google/javascript/jscomp/NameBasedDefinitionProvider.java

@@ -21,6 +21,7 @@
 import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.LinkedHashMultimap;
 import com.google.common.collect.Maps;
@@ -38,9 +39,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import javax.annotation.Nullable;
 
 /**
- * Simple name-based definition gatherer that implements {@link DefinitionProvider}.
+ * Simple name-based definition gatherer.
  *
  * <p>It treats all variable writes as happening in the global scope and treats all objects as
  * capable of having the same set of properties. The current implementation only handles definitions
@@ -52,7 +54,7 @@
  * use the type system to make this more accurate, in practice after disambiguate properties has
  * run, names are unique enough that this works well enough to accept the performance gain.
  */
-public class NameBasedDefinitionProvider implements DefinitionProvider, CompilerPass {
+public class NameBasedDefinitionProvider implements CompilerPass {
 
   protected final AbstractCompiler compiler;
 
@@ -156,13 +158,16 @@ private void dropUntypedExterns() {
     }
   }
 
-  @Override
+  /**
+   * Returns a collection of definitions that characterize the possible values of a variable or
+   * property.
+   */
   public Collection<Definition> getDefinitionsReferencedAt(Node useSiteNode) {
     checkState(hasProcessBeenRun, "Hasn't been initialized with process() yet.");
-    checkArgument(useSiteNode.isGetProp() || useSiteNode.isName());
+    checkArgument(useSiteNode.isGetProp() || useSiteNode.isName(), useSiteNode);
 
     if (definitionNodes.contains(useSiteNode)) {
-      return null;
+      return ImmutableList.of();
     }
 
     if (useSiteNode.isGetProp()) {
@@ -174,10 +179,9 @@ public Collection<Definition> getDefinitionsReferencedAt(Node useSiteNode) {
 
     String name = getSimplifiedName(useSiteNode);
     if (name != null) {
-      Collection<Definition> definitions = definitionsByName.get(name);
-      return definitions.isEmpty() ? null : definitions;
+      return definitionsByName.get(name);
     }
-    return null;
+    return ImmutableList.of();
   }
 
   private class DefinitionGatheringCallback implements Callback, ChangeScopeRootCallback {
@@ -215,13 +219,13 @@ public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
     @Override
     public void visit(NodeTraversal traversal, Node node, Node parent) {
       if (inExterns) {
-        visitExterns(traversal, node, parent);
+        visitExterns(traversal, node);
       } else {
         visitCode(traversal, node);
       }
     }
 
-    private void visitExterns(NodeTraversal traversal, Node node, Node parent) {
+    private void visitExterns(NodeTraversal traversal, Node node) {
       if (node.getJSDocInfo() != null) {
         for (Node typeRoot : node.getJSDocInfo().getTypeNodes()) {
           traversal.traverse(typeRoot);
@@ -301,6 +305,7 @@ private void addDefinition(
    * <p>TODO(user) revisit. it would be helpful to at least use fully qualified names in the case of
    * namespaces. Might not matter as much if this pass runs after {@link CollapseProperties}.
    */
+  @Nullable
   public static String getSimplifiedName(Node node) {
     if (node.isName()) {
       String name = node.getString();
@@ -320,7 +325,6 @@ public static String getSimplifiedName(Node node) {
    *
    * @return definition site collection.
    */
-  @Override
   public Collection<DefinitionSite> getDefinitionSites() {
     checkState(hasProcessBeenRun, "Hasn't been initialized with process() yet.");
     return definitionSitesByDefinitionSiteNode.values();

src/com/google/javascript/jscomp/NodeUtil.java

@@ -4885,7 +4885,7 @@ static boolean mayBeUndefined(Node n) {
   /**
    * @return Whether the provided expression is known not to evaluate to 'undefined'.
    *
-   * Similiar to #getKnownValueType only for 'undefined'.  This is useful for simplifing
+   * Similar to #getKnownValueType only for 'undefined'.  This is useful for simplifying
    * default value expressions.
    */
   static boolean isDefinedValue(Node value) {

src/com/google/javascript/jscomp/PureFunctionIdentifier.java

@@ -71,7 +71,7 @@
  */
 class PureFunctionIdentifier implements CompilerPass {
   private final AbstractCompiler compiler;
-  private final DefinitionProvider definitionProvider;
+  private final NameBasedDefinitionProvider definitionProvider;
 
   /** Map of function names to side effect gathering representative nodes */
   private final Map<String, FunctionInformation> functionInfoByName = new HashMap<>();
@@ -105,7 +105,8 @@ class PureFunctionIdentifier implements CompilerPass {
   private Node externs;
   private Node root;
 
-  public PureFunctionIdentifier(AbstractCompiler compiler, DefinitionProvider definitionProvider) {
+  public PureFunctionIdentifier(
+      AbstractCompiler compiler, NameBasedDefinitionProvider definitionProvider) {
     this.compiler = checkNotNull(compiler);
     this.definitionProvider = definitionProvider;
     this.functionSideEffectMap = ArrayListMultimap.create();
@@ -353,8 +354,8 @@ private void addSupportedDefinition(DefinitionSite definitionSite, String name)
 
   /**
    * Propagate side effect information by building a graph based on call site information stored in
-   * FunctionInformation and the DefinitionProvider and then running GraphReachability to determine
-   * the set of functions that have side effects.
+   * FunctionInformation and the NameBasedDefinitionProvider and then running GraphReachability to
+   * determine the set of functions that have side effects.
    */
   private void propagateSideEffects() {
     // Propagate side effect information to a fixed point.