Suppress follow-on errors when a file is imported with either a prefix or a show clause

pkg/analyzer/lib/src/dart/resolver/scope.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.dart.resolver.scope;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 107 matching lines @@
       return element;
     }
     // May be there is a hidden Element.
     if (_hiddenElements != null) {
       Element hiddenElement = _hiddenElements[name];
       if (hiddenElement != null) {
         errorListener.onError(new AnalysisError(
             getSource(identifier),
             identifier.offset,
             identifier.length,
-            CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, [name]));
+            CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION,
+            [name]));
         return hiddenElement;
       }
     }
     // Check enclosing scope.
     return enclosingScope.internalLookup(identifier, name, referencingLibrary);
   }
 
   @override
   Element _internalLookupPrefixed(Identifier identifier, String prefix,
       String name, LibraryElement referencingLibrary) {
@@ skipping 292 matching lines @@
         StringUtilities.printListOfQuotedNames(libraryNames)
       ]));
       return foundElement;
     }
     if (foundElement != null) {
       defineNameWithoutChecking(name, foundElement);
     }
     return foundElement;
   }
 
+  @override
+  bool shouldIgnoreUndefined(Identifier node) {
+    bool exists(ImportElement importElement) =>
+        importElement.context.exists(importElement.importedLibrary.source);

[scheglov, 2016/08/08 21:10:20]

AnalysisContext.exists() is an expensive operation, especially on NFS.
Maybe we could remember whether the import directive resolves to an existing
source in the element.

[Brian Wilkerson, 2016/08/08 21:19:29]

Yeah, I considered that possibility, but forgot to go back and implement it.

+    Iterable<NamespaceCombinator> getShowCombinators(
+            ImportElement importElement) =>
+        importElement.combinators.where((NamespaceCombinator combinator) =>
+            combinator is ShowElementCombinator);
+    if (node is PrefixedIdentifier) {
+      String prefix = node.prefix.name;
+      String name = node.identifier.name;
+      List<ImportElement> imports = _definingLibrary.imports;
+      int count = imports.length;
+      for (int i = 0; i < count; i++) {
+        ImportElement importElement = imports[i];
+        if (importElement.prefix?.name == prefix && !exists(importElement)) {

[scheglov, 2016/08/08 21:10:20]

What if there is an import with the same prefix name, but with an existing
source?

[Brian Wilkerson, 2016/08/08 21:19:29]

Then presumably we would have found the corresponding element when we looked the
name up and we would never invoke this method. The intent is that this method is
only invoked when we find a name that couldn't be resolved in order to determine
whether to report the fact.

+          Iterable<NamespaceCombinator> showCombinators =
+              getShowCombinators(importElement);
+          if (showCombinators.isEmpty) {
+            return true;
+          }
+          for (ShowElementCombinator combinator in showCombinators) {
+            if (combinator.shownNames.contains(name)) {
+              return true;
+            }
+          }
+        }
+      }
+    } else if (node is SimpleIdentifier) {
+      String name = node.name;
+      List<ImportElement> imports = _definingLibrary.imports;
+      int count = imports.length;
+      for (int i = 0; i < count; i++) {
+        ImportElement importElement = imports[i];
+        if (importElement.prefix == null && !exists(importElement)) {
+          for (ShowElementCombinator combinator
+              in getShowCombinators(importElement)) {
+            if (combinator.shownNames.contains(name)) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
+
   /**
    * Create all of the namespaces associated with the libraries imported into
    * this library. The names are not added to this scope, but are stored for
    * later reference.
    */
   void _createImportedNamespaces() {
     NamespaceBuilder builder = new NamespaceBuilder();
     List<ImportElement> imports = _definingLibrary.imports;
     int count = imports.length;
     _importedNamespaces = new List<Namespace>(count);
@@ skipping 63 matching lines @@
   }
 
   @override
   Element _internalLookupPrefixed(Identifier identifier, String prefix,
       String name, LibraryElement referencingLibrary) {
     Element foundElement = _localPrefixedLookup(prefix, name);
     if (foundElement != null) {
       return foundElement;
     }
     for (int i = 0; i < _importedNamespaces.length; i++) {
-      Namespace nameSpace = _importedNamespaces[i];
-      Element element = nameSpace.getPrefixed(prefix, name);
+      Element element = _importedNamespaces[i].getPrefixed(prefix, name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
         } else if (!identical(foundElement, element)) {
           foundElement = MultiplyDefinedElementImpl.fromElements(
               _definingLibrary.context, foundElement, element);
         }
       }
     }
     Element element = foundElement;
@@ skipping 618 matching lines @@
    */
   Element lookup(Identifier identifier, LibraryElement referencingLibrary) {
     if (identifier is PrefixedIdentifier) {
       return _internalLookupPrefixed(identifier, identifier.prefix.name,
           identifier.identifier.name, referencingLibrary);
     }
     return internalLookup(identifier, identifier.name, referencingLibrary);
   }
 
   /**
+   * Return `true` if the fact that the given [node] is not defined should be
+   * ignored (from the perspective of error reporting). This will be the case if
+   * there is at least one import that defines the node's prefix, and if that
+   * import either has no show combinators or has a show combinator that
+   * explicitly lists the node's name.
+   */
+  bool shouldIgnoreUndefined(Identifier node) {
+    if (enclosingScope != null) {
+      return enclosingScope.shouldIgnoreUndefined(node);
+    }
+    return false;
+  }
+
+  /**
    * Return the name that will be used to look up the given [element].
    */
   String _getName(Element element) {
     if (element is MethodElement) {
       MethodElement method = element;
       if (method.name == "-" && method.parameters.length == 0) {
         return UNARY_MINUS;
       }
     }
     return element.name;
@@ skipping 35 matching lines @@
 
   /**
    * Define the type parameters declared by the [classElement].
    */
   void _defineTypeParameters(ClassElement classElement) {
     for (TypeParameterElement typeParameter in classElement.typeParameters) {
       define(typeParameter);
     }
   }
 }