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

pkg/analyzer/lib/src/dart/element/element.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.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 4139 matching lines @@
     return super.uriEnd;
   }
 
   @override
   void set uriEnd(int uriEnd) {
     assert(_unlinkedExportNonPublic == null);
     super.uriEnd = uriEnd;
   }
 
   @override
+  bool get uriExists {
+    if (_unlinkedExportNonPublic != null) {
+      return true;
+    }
+    return hasModifier(Modifier.URI_EXISTS);
+  }
+
+  /**
+   * Set whether the file referenced by the import's URI exists to match the
+   * given flag.
+   */
+  void set uriExists(bool exists) {
+    assert(_unlinkedExportNonPublic == null);
+    setModifier(Modifier.URI_EXISTS, exists);
+  }
+
+  @override
   int get uriOffset {
     if (_unlinkedExportNonPublic != null) {
       return _unlinkedExportNonPublic.uriOffset;
     }
     return super.uriOffset;
   }
 
   @override
   void set uriOffset(int uriOffset) {
     assert(_unlinkedExportNonPublic == null);
@@ skipping 923 matching lines @@
     return super.uriEnd;
   }
 
   @override
   void set uriEnd(int uriEnd) {
     assert(_unlinkedImport == null);
     super.uriEnd = uriEnd;
   }
 
   @override
+  bool get uriExists {
+    if (_unlinkedImport != null) {
+      return true;
+    }
+    return hasModifier(Modifier.URI_EXISTS);
+  }
+
+  /**
+   * Set whether the file referenced by the import's URI exists to match the
+   * given flag.
+   */
+  void set uriExists(bool exists) {
+    assert(_unlinkedImport == null);
+    setModifier(Modifier.URI_EXISTS, exists);
+  }
+
+  @override
   int get uriOffset {
     if (_unlinkedImport != null) {
       if (_unlinkedImport.isImplicit) {
         return -1;
       }
       return _unlinkedImport.uriOffset;
     }
     return super.uriOffset;
   }
 
@@ skipping 548 matching lines @@
         // TODO(paulberry): this means that computing a library cycle will be
         // expensive for libraries resynthesized from summaries, since it will
         // require fully resynthesizing all the libraries in the cycle as well
         // as any libraries they import or export.  Try to find a better way.
         if (lib is LibraryElementHandle) {
           return lib.actualElement;
         } else {
           return lib;
         }
       }
+
       void recurse(LibraryElementImpl child) {
         if (!indices.containsKey(child)) {
           // We haven't visited this child yet, so recurse on the child,
           // returning the lowest numbered node reachable from the child.  If
           // the child can reach a root which is lower numbered than anything
           // we've reached so far, update the root.
           root = min(root, scc(child));
         } else if (active.contains(child)) {
           // The child has been visited, but has not yet been placed into a
           // component.  If the child is higher than anything we've seen so far
           // update the root appropriately.
           root = min(root, indices[child]);
         }
       }
+
       // Recurse on all of the children in the import/export graph, filtering
       // out those for which library cycles have already been computed.
       library.exportedLibraries
           .map(getActualLibrary)
           .where((l) => l._libraryCycle == null)
           .forEach(recurse);
       library.importedLibraries
           .map(getActualLibrary)
           .where((l) => l._libraryCycle == null)
           .forEach(recurse);
 
       if (root == index) {
         // This is the root of a strongly connected component.
         // Pop the elements, and share the component across all
         // of the elements.
         List<LibraryElement> component = <LibraryElement>[];
         LibraryElementImpl cur = null;
         do {
           cur = stack.removeLast();
           active.remove(cur);
           component.add(cur);
           cur._libraryCycle = component;
         } while (cur != library);
       }
       return root;
     }
+
     scc(library);
     return _libraryCycle;
   }
 
   @override
   FunctionElement get loadLibraryFunction {
     assert(_loadLibraryFunction != null);
     return _loadLibraryFunction;
   }
 
@@ skipping 179 matching lines @@
           element is LibraryElementHandle ? element.actualElement : element;
       if (active.add(library)) {
         if (library._libraryCycle != null) {
           library._libraryCycle.forEach(invalidate);
           library._libraryCycle = null;
         }
         library.exportedLibraries.forEach(invalidate);
         library.importedLibraries.forEach(invalidate);
       }
     }
+
     invalidate(this);
   }
 
   @override
   bool isUpToDate(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return _safeIsUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
@@ skipping 468 matching lines @@
   static const Modifier STATIC = const Modifier('STATIC', 15);
 
   /**
    * Indicates that the element does not appear in the source code but was
    * implicitly created. For example, if a class does not define any
    * constructors, an implicit zero-argument constructor will be created and it
    * will be marked as being synthetic.
    */
   static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 16);
 
+  /**
+   * A flag used for import and export elements that indicates whether the URI
+   * in the corresponding directive referenced a file that exists.
+   */
+  static const Modifier URI_EXISTS = const Modifier('URI_EXISTS', 17);
+
   static const List<Modifier> values = const [
     ABSTRACT,
     ASYNCHRONOUS,
     CONST,
     DEFERRED,
     ENUM,
     EXTERNAL,
     FACTORY,
     FINAL,
     GENERATOR,
     GETTER,
     HAS_EXT_URI,
     IMPLICIT_TYPE,
     MIXIN_APPLICATION,
     REFERENCES_SUPER,
     SETTER,
     STATIC,
-    SYNTHETIC
+    SYNTHETIC,
+    URI_EXISTS
   ];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * A concrete implementation of a [MultiplyDefinedElement].
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
   /**
@@ skipping 2049 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }