Don't throw exceptions for unresolved/not-existing URIs in directives.

pkg/analyzer/lib/src/generated/resolver.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.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 592 matching lines @@
       if (!_typeSystem.isAssignableTo(bestRightType, leftType)) {
         _errorReporter.reportTypeErrorForNode(
             HintCode.INVALID_ASSIGNMENT, rhs, [bestRightType, leftType]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Produces a hint if the given identifier is a protected field or getter
-   * accessed outside a subclass.
-   */
-  void _checkForInvalidProtectedPropertyAccess(SimpleIdentifier identifier) {
-    if (identifier.inDeclarationContext()) {
-      return;
-    }
-    Element element = identifier.bestElement;
-    if (element is PropertyAccessorElement &&
-        (element.isProtected || element.variable.isProtected)) {
-      ClassElement definingClass = element.enclosingElement;
-      if (definingClass == null) {
-        return;
-      }
-      ClassDeclaration accessingClass =
-          identifier.getAncestor((AstNode node) => node is ClassDeclaration);
-
-      if (accessingClass == null) {
-        _errorReporter.reportErrorForNode(
-            HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
-            identifier,
-            [identifier.name.toString(), definingClass.name]);
-      } else if (!_hasSuperClassOrMixin(
-          accessingClass.element, definingClass.type)) {
-        _errorReporter.reportErrorForNode(
-            HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
-            identifier,
-            [identifier.name.toString(), definingClass.name]);
-      }
-    }
-  }
-
-  /**
    * Produces a hint if the given invocation is of a protected method outside
    * a subclass instance method.
    */
   void _checkForInvalidProtectedMethodCalls(MethodInvocation node) {
     Element element = node.methodName.bestElement;
     if (element == null || !element.isProtected) {
       return;
     }
 
     ClassElement definingClass = element.enclosingElement;
@@ skipping 13 matching lines @@
       if (!_hasSuperClassOrMixin(invokingClass, definingClass.type)) {
         _errorReporter.reportErrorForNode(
             HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
             node,
             [node.methodName.toString(), definingClass.name]);
       }
     }
   }
 
   /**
+   * Produces a hint if the given identifier is a protected field or getter
+   * accessed outside a subclass.
+   */
+  void _checkForInvalidProtectedPropertyAccess(SimpleIdentifier identifier) {
+    if (identifier.inDeclarationContext()) {
+      return;
+    }
+    Element element = identifier.bestElement;
+    if (element is PropertyAccessorElement &&
+        (element.isProtected || element.variable.isProtected)) {
+      ClassElement definingClass = element.enclosingElement;
+      if (definingClass == null) {
+        return;
+      }
+      ClassDeclaration accessingClass =
+          identifier.getAncestor((AstNode node) => node is ClassDeclaration);
+
+      if (accessingClass == null) {
+        _errorReporter.reportErrorForNode(
+            HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
+            identifier,
+            [identifier.name.toString(), definingClass.name]);
+      } else if (!_hasSuperClassOrMixin(
+          accessingClass.element, definingClass.type)) {
+        _errorReporter.reportErrorForNode(
+            HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
+            identifier,
+            [identifier.name.toString(), definingClass.name]);
+      }
+    }
+  }
+
+  /**
    * Check that the imported library does not define a loadLibrary function. The import has already
    * been determined to be deferred when this is called.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION].
    */
   bool _checkForLoadLibraryFunction(
       ImportDirective node, ImportElement importElement) {
@@ skipping 1428 matching lines @@
     }
   }
 }
 
 /**
  * A visitor that resolves declarations in an AST structure to already built
  * elements.
  */
 class DeclarationResolver extends RecursiveAstVisitor<Object> {
   /**
+   * The analysis context containing the sources to be analyzed.
+   */
+  AnalysisContext _context;
+
+  /**
    * The elements that are reachable from the compilation unit element. When a
    * compilation unit has been resolved, this set should be empty.
    */
   Set<Element> _expectedElements;
 
   /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
@@ skipping 20 matching lines @@
    * not in the scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
   /**
    * Resolve the declarations within the given compilation [unit] to the
    * elements rooted at the given [element]. Throw an [ElementMismatchException]
    * if the element model and compilation unit do not match each other.
    */
   void resolve(CompilationUnit unit, CompilationUnitElement element) {
+    _context = element.context;
     ElementGatherer gatherer = new ElementGatherer();
     element.accept(gatherer);
     _expectedElements = gatherer.elements;
     _enclosingUnit = element;
     _expectedElements.remove(element);
     unit.element = element;
     unit.accept(this);
     _validateResolution();
   }
 
@@ skipping 117 matching lines @@
     _resolveMetadata(node.metadata, enclosingEnum);
     return null;
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     String uri = _getStringValue(node.uri);
     ExportElement exportElement;
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      exportElement = _findExport(
-          node,
-          library.exports,
-          _enclosingUnit.context.sourceFactory
-              .resolveUri(_enclosingUnit.source, uri));
+      Source source = _enclosingUnit.context.sourceFactory
+          .resolveUri(_enclosingUnit.source, uri);
+      exportElement = _findExport(node, library.exports, source);
       node.element = exportElement;
     }
     super.visitExportDirective(node);
     _resolveMetadata(node.metadata, exportElement);
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     super.visitFieldDeclaration(node);
@@ skipping 116 matching lines @@
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
     ImportElement importElement;
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      importElement = _findImport(
-          node,
-          library.imports,
-          _enclosingUnit.context.sourceFactory
-              .resolveUri(_enclosingUnit.source, uri));
+      Source source = _enclosingUnit.context.sourceFactory
+          .resolveUri(_enclosingUnit.source, uri);
+      importElement = _findImport(node, library.imports, source);
       node.element = importElement;
     }
     super.visitImportDirective(node);
     _resolveMetadata(node.metadata, importElement);
     return null;
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
@@ skipping 190 matching lines @@
   Element _findAtOffset(List<Element> elements, AstNode node, int offset) =>
       _findWithNameAndOffset(elements, node, '', offset);
 
   /**
    * Return the export element from the given list of [exports] whose library
    * has the given [source]. Throw an [ElementMismatchException] if an element
    * corresponding to the identifier cannot be found.
    */
   ExportElement _findExport(
       ExportDirective node, List<ExportElement> exports, Source source) {
+    if (source == null || !_context.exists(source)) {
+      return null;
+    }
     for (ExportElement export in exports) {
       if (export.exportedLibrary.source == source) {
         return export;
       }
     }
     _mismatch("Could not find export element for '$source'", node);
     return null; // Never reached
   }
 
   /**
    * Return the element in the given list of [elements] that was created for the
    * declaration with the given [identifier]. As a side-effect, associate the
    * returned element with the identifier. Throw an [ElementMismatchException]
    * if an element corresponding to the identifier cannot be found unless
    * [required] is `false`, in which case return `null`.
    */
   Element _findIdentifier(List<Element> elements, SimpleIdentifier identifier,
       {bool required: true}) {
     Element element = _findWithNameAndOffset(
         elements, identifier, identifier.name, identifier.offset,
         required: required);
     _expectedElements.remove(element);
     identifier.staticElement = element;
     return element;
   }
 
   /**
    * Return the import element from the given list of [imports] whose library
-   * has the given [source] and that has the given [prefix]. Throw an
-   * [ElementMismatchException] if an element corresponding to the identifier
-   * cannot be found.
+   * has the given [source]. Throw an [ElementMismatchException] if an element
+   * corresponding to the [source] cannot be found.
    */
   ImportElement _findImport(
       ImportDirective node, List<ImportElement> imports, Source source) {
+    if (source == null || !_context.exists(source)) {
+      return null;
+    }
     SimpleIdentifier prefix = node.prefix;
     bool foundSource = false;
     for (ImportElement element in imports) {
       if (element.importedLibrary.source == source) {
         foundSource = true;
         PrefixElement prefixElement = element.prefix;
         if (prefix == null) {
           if (prefixElement == null) {
             return element;
           }
@@ skipping 10276 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }