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) {
+    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 && !importElement.uriExists) {
+          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 && !importElement.uriExists) {
+          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);
     }
   }
 }