New analyzer snapshot.

pkg/analyzer/lib/src/generated/engine.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'java_core.dart';
@@ skipping 868 matching lines @@
     this._notices = notices;
   }
 
   /**
    * Return the change notices associated with this result, or `null` if there were no changes
    * and there is no more work to be done.
    *
    * @return the change notices associated with this result
    */
   List<ChangeNotice> get changeNotices => _notices;
+
+  /**
+   * Return `true` if there is more to be performed after the task that was performed.
+   *
+   * @return `true` if there is more to be performed after the task that was performed
+   */
+  bool get hasMoreWork => _notices != null;
 }
 
 /**
  * The interface `ChangeNotice` defines the behavior of objects that represent a change to the
  * analysis results associated with a given source.
  */
 abstract class ChangeNotice implements AnalysisErrorInfo {
   /**
    * Return the fully resolved AST that changed as a result of the analysis, or `null` if the
    * AST was not changed.
@@ skipping 464 matching lines @@
    * The data descriptor representing the errors reported during Angular resolution.
    */
   static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS");
 
   /**
    * The data descriptor representing the list of libraries that contain this compilation unit.
    */
   static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.CONTAINING_LIBRARIES");
 
   /**
+   * The data descriptor representing the errors reported during the resolution of directives.
+   */
+  static final DataDescriptor<List<AnalysisError>> DIRECTIVE_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.DIRECTIVE_ERRORS");
+
+  /**
    * The data descriptor representing the library element for the library. This data is only
    * available for Dart files that are the defining compilation unit of a library.
    */
   static final DataDescriptor<LibraryElement> ELEMENT = new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
 
   /**
    * The data descriptor representing the list of exported libraries. This data is only available
    * for Dart files that are the defining compilation unit of a library.
    */
   static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.EXPORTED_LIBRARIES");
@@ skipping 151 matching lines @@
    * The head of the token stream, or `null` if the token stream is not currently cached.
    */
   Token _tokenStream;
 
   /**
    * The state of the cached scan errors.
    */
   CacheState _scanErrorsState = CacheState.INVALID;
 
   /**
-   * The errors produced while scanning the compilation unit, or `null` if the errors are not
-   * currently cached.
+   * The errors produced while scanning the compilation unit, or an empty array if the errors are
+   * not currently cached.
    */
   List<AnalysisError> _scanErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The state of the cached source kind.
    */
   CacheState _sourceKindState = CacheState.INVALID;
 
   /**
    * The kind of this source.
@@ skipping 16 matching lines @@
    * cached.
    */
   CompilationUnit _parsedUnit;
 
   /**
    * The state of the cached parse errors.
    */
   CacheState _parseErrorsState = CacheState.INVALID;
 
   /**
-   * The errors produced while parsing the compilation unit, or `null` if the errors are not
+   * The errors produced while parsing the compilation unit, or an empty array if the errors are not
    * currently cached.
    */
   List<AnalysisError> _parseErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The state of the cached list of imported libraries.
    */
   CacheState _importedLibrariesState = CacheState.INVALID;
 
   /**
@@ skipping 18 matching lines @@
    */
   CacheState _includedPartsState = CacheState.INVALID;
 
   /**
    * The list of parts included in the library, or an empty array if the list is not currently
    * cached. The list will be empty if the Dart file is a part rather than a library.
    */
   List<Source> _includedParts = Source.EMPTY_ARRAY;
 
   /**
+   * The state of the cached directive errors.
+   */
+  CacheState _directiveErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while resolving the directives, or an empty array if the errors are not
+   * currently cached.
+   */
+  List<AnalysisError> _directiveErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * The list of libraries that contain this compilation unit. The list will be empty if there are
    * no known libraries that contain this compilation unit.
    */
   List<Source> _containingLibraries = new List<Source>();
 
   /**
    * The information known as a result of resolving this compilation unit as part of the library
    * that contains this unit. This field will never be `null`.
    */
   DartEntryImpl_ResolutionState _resolutionState = new DartEntryImpl_ResolutionState();
@@ skipping 76 matching lines @@
       _parsedUnit = null;
     }
     _resolutionState.flushAstStructures();
   }
 
   @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     ListUtilities.addAll(errors, _scanErrors);
     ListUtilities.addAll(errors, _parseErrors);
+    ListUtilities.addAll(errors, _directiveErrors);
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       ListUtilities.addAll(errors, state._resolutionErrors);
       ListUtilities.addAll(errors, state._verificationErrors);
       ListUtilities.addAll(errors, state._hints);
       state = state._nextState;
     }
     ListUtilities.addAll(errors, _angularErrors);
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
@@ skipping 64 matching lines @@
         return state._resolvedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
   @override
   CacheState getState(DataDescriptor descriptor) {
-    if (identical(descriptor, DartEntry.ELEMENT)) {
+    if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
+      return _directiveErrorsState;
+    } else if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return _clientServerState;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
@@ skipping 41 matching lines @@
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
     } else if (identical(descriptor, DartEntry.CONTAINING_LIBRARIES)) {
       return new List.from(_containingLibraries);
+    } else if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
+      return _directiveErrors;
     } else if (identical(descriptor, DartEntry.ELEMENT)) {
       return _element;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibraries;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibraries;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedParts;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return BooleanArray.get(_bitmask, _CLIENT_CODE_INDEX);
@@ skipping 47 matching lines @@
 
   @override
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
   @override
   bool hasInvalidData(DataDescriptor descriptor) {
-    if (identical(descriptor, DartEntry.ELEMENT)) {
+    if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
+      return identical(_directiveErrorsState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.ELEMENT)) {
       return identical(_elementState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return identical(_exportedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return identical(_importedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return identical(_includedPartsState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return identical(_clientServerState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
@@ skipping 88 matching lines @@
    * Record that an error occurred while attempting to resolve the directives in the source
    * represented by this entry.
    */
   void recordDependencyError() {
     _exportedLibraries = Source.EMPTY_ARRAY;
     _exportedLibrariesState = CacheState.ERROR;
     _importedLibraries = Source.EMPTY_ARRAY;
     _importedLibrariesState = CacheState.ERROR;
     _includedParts = Source.EMPTY_ARRAY;
     _includedPartsState = CacheState.ERROR;
+    _directiveErrors = AnalysisError.NO_ERRORS;
+    _directiveErrorsState = CacheState.ERROR;
   }
 
   /**
    * Record that the information related to resolving dependencies for the associated source is
    * about to be computed by the current thread.
    */
   void recordDependencyInProcess() {
     if (_exportedLibrariesState != CacheState.VALID) {
       _exportedLibrariesState = CacheState.IN_PROCESS;
     }
     if (_importedLibrariesState != CacheState.VALID) {
       _importedLibrariesState = CacheState.IN_PROCESS;
     }
     if (_includedPartsState != CacheState.VALID) {
       _includedPartsState = CacheState.IN_PROCESS;
     }
+    if (_directiveErrorsState != CacheState.VALID) {
+      _directiveErrorsState = CacheState.IN_PROCESS;
+    }
   }
 
   /**
    * Record that an in-process dependency resolution has stopped without recording results because
    * the results were invalidated before they could be recorded.
    */
   void recordDependencyNotInProcess() {
     if (identical(_exportedLibrariesState, CacheState.IN_PROCESS)) {
       _exportedLibrariesState = CacheState.INVALID;
     }
     if (identical(_importedLibrariesState, CacheState.IN_PROCESS)) {
       _importedLibrariesState = CacheState.INVALID;
     }
     if (identical(_includedPartsState, CacheState.IN_PROCESS)) {
       _includedPartsState = CacheState.INVALID;
     }
+    if (identical(_directiveErrorsState, CacheState.IN_PROCESS)) {
+      _directiveErrorsState = CacheState.INVALID;
+    }
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
    */
   void recordParseError() {
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.ERROR;
@@ skipping 169 matching lines @@
    *
    * @param librarySource the source of the single library that the list should contain
    */
   void set containingLibrary(Source librarySource) {
     _containingLibraries.clear();
     _containingLibraries.add(librarySource);
   }
 
   @override
   void setState(DataDescriptor descriptor, CacheState state) {
-    if (identical(descriptor, DartEntry.ELEMENT)) {
+    if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
+      _directiveErrors = updatedValue(state, _directiveErrors, null);
+      _directiveErrorsState = state;
+    } else if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = updatedValue(state, _exportedLibraries, Source.EMPTY_ARRAY);
       _exportedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = updatedValue(state, _importedLibraries, Source.EMPTY_ARRAY);
       _importedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       _includedParts = updatedValue(state, _includedParts, Source.EMPTY_ARRAY);
@@ skipping 56 matching lines @@
       state._hintsState = cacheState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       _angularErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
+    } else if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
+      _directiveErrors = value as List<AnalysisError>;
+      _directiveErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = value as LibraryElement;
       _elementState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _exportedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _importedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
@@ skipping 69 matching lines @@
     _parsedUnit = other._parsedUnit;
     _parsedUnitAccessed = other._parsedUnitAccessed;
     _parseErrorsState = other._parseErrorsState;
     _parseErrors = other._parseErrors;
     _includedPartsState = other._includedPartsState;
     _includedParts = other._includedParts;
     _exportedLibrariesState = other._exportedLibrariesState;
     _exportedLibraries = other._exportedLibraries;
     _importedLibrariesState = other._importedLibrariesState;
     _importedLibraries = other._importedLibraries;
+    _directiveErrorsState = other._directiveErrorsState;
+    _directiveErrors = other._directiveErrors;
     _containingLibraries = new List<Source>.from(other._containingLibraries);
     _resolutionState.copyFrom(other._resolutionState);
     _elementState = other._elementState;
     _element = other._element;
     _publicNamespaceState = other._publicNamespaceState;
     _publicNamespace = other._publicNamespace;
     _clientServerState = other._clientServerState;
     _launchableState = other._launchableState;
     _bitmask = other._bitmask;
     _angularErrors = other._angularErrors;
   }
 
   @override
-  bool get hasErrorState => super.hasErrorState || identical(_scanErrorsState, CacheState.ERROR) || identical(_tokenStreamState, CacheState.ERROR) || identical(_sourceKindState, CacheState.ERROR) || identical(_parsedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_importedLibrariesState, CacheState.ERROR) || identical(_exportedLibrariesState, CacheState.ERROR) || identical(_includedPartsState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_publicNamespaceState, CacheState.ERROR) || identical(_clientServerState, CacheState.ERROR) || identical(_launchableState, CacheState.ERROR) || _resolutionState.hasErrorState;
+  bool get hasErrorState => super.hasErrorState || identical(_scanErrorsState, CacheState.ERROR) || identical(_tokenStreamState, CacheState.ERROR) || identical(_sourceKindState, CacheState.ERROR) || identical(_parsedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_importedLibrariesState, CacheState.ERROR) || identical(_exportedLibrariesState, CacheState.ERROR) || identical(_includedPartsState, CacheState.ERROR) || identical(_directiveErrorsState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_publicNamespaceState, CacheState.ERROR) || identical(_clientServerState, CacheState.ERROR) || identical(_launchableState, CacheState.ERROR) || _resolutionState.hasErrorState;
 
   @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Dart: ");
     super.writeOn(builder);
     builder.append("; tokenStream = ");
     builder.append(_tokenStreamState);
     builder.append("; scanErrors = ");
     builder.append(_scanErrorsState);
     builder.append("; sourceKind = ");
     builder.append(_sourceKindState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append(" (");
     builder.append(_parsedUnitAccessed ? "T" : "F");
     builder.append("); parseErrors = ");
     builder.append(_parseErrorsState);
     builder.append("; exportedLibraries = ");
     builder.append(_exportedLibrariesState);
     builder.append("; importedLibraries = ");
     builder.append(_importedLibrariesState);
     builder.append("; includedParts = ");
     builder.append(_includedPartsState);
+    builder.append("; directiveErrors = ");
+    builder.append(_directiveErrorsState);
     builder.append("; element = ");
     builder.append(_elementState);
     builder.append("; publicNamespace = ");
     builder.append(_publicNamespaceState);
     builder.append("; clientServer = ");
     builder.append(_clientServerState);
     builder.append("; launchable = ");
     builder.append(_launchableState);
     //    builder.append("; angularElements = ");
     _resolutionState.writeOn(builder);
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void _discardCachedResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
     _includedParts = Source.EMPTY_ARRAY;
     _includedPartsState = CacheState.INVALID;
     _exportedLibraries = Source.EMPTY_ARRAY;
     _exportedLibrariesState = CacheState.INVALID;
     _importedLibraries = Source.EMPTY_ARRAY;
     _importedLibrariesState = CacheState.INVALID;
+    _directiveErrors = AnalysisError.NO_ERRORS;
+    _directiveErrorsState = CacheState.INVALID;
     _bitmask = 0;
     _clientServerState = CacheState.INVALID;
     _launchableState = CacheState.INVALID;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.INVALID;
     _resolutionState.invalidateAllResolutionInformation();
   }
 
   /**
    * Return a resolution state for the specified library, creating one as necessary.
@@ skipping 2340 matching lines @@
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
-      dartEntry = new ResolveDartDependenciesTask(this, source, dartEntry.modificationTime, dartEntry.anyParsedCompilationUnit).perform(_resultRecorder) as DartEntry;
+      CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
+      if (unit == null) {
+        throw new AnalysisException.con2("Could not cache Dart dependency data: no parse unit", dartEntry.exception);
+      }
+      dartEntry = new ResolveDartDependenciesTask(this, source, dartEntry.modificationTime, unit).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by generating hints
    * for the library if the data is not already cached.
@@ skipping 2036 matching lines @@
           DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null && partEntry != dartEntry) {
             DartEntryImpl partCopy = partEntry.writableCopy;
             partCopy.addContainingLibrary(source);
             _cache.put(partSource, partCopy);
           }
         }
         dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
         dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
         dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
+        dartCopy.setValue(DartEntry.DIRECTIVE_ERRORS, task.errors);
       } else {
         dartCopy.recordDependencyError();
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
       _logInformation2("Dependency resolution results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
@@ skipping 4367 matching lines @@
 
   /**
    * Return the compilation unit that was produced by parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the compilation unit that was produced by parsing the source
    */
   CompilationUnit get compilationUnit => _unit;
 
   /**
-   * Return the errors that were produced by scanning and parsing the source, or `null` if the
-   * task has not yet been performed or if an exception occurred.
+   * Return the errors that were produced by scanning and parsing the source, or an empty array if
+   * the task has not yet been performed or if an exception occurred.
    *
    * @return the errors that were produced by scanning and parsing the source
    */
   List<AnalysisError> get errors => _errors;
 
   /**
    * Return `true` if the source contains a 'library' directive, or `false` if the task
    * has not yet been performed or if an exception occurred.
    *
    * @return `true` if the source contains a 'library' directive
@@ skipping 439 matching lines @@
    * A set containing the sources referenced by 'import' directives.
    */
   Set<Source> _importedSources = new Set<Source>();
 
   /**
    * A set containing the sources referenced by 'part' directives.
    */
   Set<Source> _includedSources = new Set<Source>();
 
   /**
+   * The errors that were produced by resolving the directives.
+   */
+  List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The prefix of a URI using the `dart-ext` scheme to reference a native code library.
+   */
+  static String _DART_EXT_SCHEME = "dart-ext:";
+
+  /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the compilation unit used to resolve the dependencies
    */
   ResolveDartDependenciesTask(InternalAnalysisContext context, this.source, this.modificationTime, CompilationUnit unit) : super(context) {
     this._unit = unit;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartDependenciesTask(this);
 
   /**
+   * Return the errors that were produced by resolving the directives, or an empty array if the task
+   * has not yet been performed or if an exception occurred.
+   *
+   * @return the errors that were produced by resolving the directives.
+   */
+  List<AnalysisError> get errors => _errors;
+
+  /**
    * Return an array containing the sources referenced by 'export' directives, or an empty array if
    * the task has not yet been performed or if an exception occurred.
    *
    * @return an array containing the sources referenced by 'export' directives
    */
   List<Source> get exportedSources => _toArray(_exportedSources);
 
   /**
    * Return an array containing the sources referenced by 'import' directives, or an empty array if
    * the task has not yet been performed or if an exception occurred.
@@ skipping 15 matching lines @@
     if (source == null) {
       return "resolve dart dependencies null source";
     }
     return "resolve dart dependencies ${source.fullName}";
   }
 
   @override
   void internalPerform() {
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
+      RecordingErrorListener errorListener = new RecordingErrorListener();
       for (Directive directive in _unit.directives) {
         if (directive is ExportDirective) {
-          Source exportSource = _resolveSource(source, directive);
+          Source exportSource = _resolveSource(source, directive, errorListener);
           if (exportSource != null) {
             _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
-          Source importSource = _resolveSource(source, directive);
+          Source importSource = _resolveSource(source, directive, errorListener);
           if (importSource != null) {
             _importedSources.add(importSource);
           }
         } else if (directive is PartDirective) {
-          Source partSource = _resolveSource(source, directive);
+          Source partSource = _resolveSource(source, directive, errorListener);
           if (partSource != null) {
             _includedSources.add(partSource);
           }
         }
       }
+      _errors = errorListener.errors;
     } finally {
       timeCounterParse.stop();
     }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
+   * @param errorListener the error listener to which errors should be reported
    * @return the result of resolving the URI against the URI of the library
    */
-  Source _resolveSource(Source librarySource, UriBasedDirective directive) {
+  Source _resolveSource(Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
-    if (uriContent == null) {
+    directive.uriContent = uriContent;
+    if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
       return null;
     }
-    uriContent = Uri.encodeFull(uriContent);
     try {
-      parseUriWithException(uriContent);
-      return context.sourceFactory.resolveUri(librarySource, uriContent);
+      String encodedUriContent = Uri.encodeFull(uriContent);
+      parseUriWithException(encodedUriContent);
+      AnalysisContext analysisContext = context;
+      Source source = analysisContext.sourceFactory.resolveUri(librarySource, encodedUriContent);
+      if (!analysisContext.exists(source)) {
+        errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
+      }
+      directive.source = source;
+      return source;
     } on URISyntaxException catch (exception) {
-      return null;
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
     }
+    return null;
   }
 
   /**
    * Efficiently convert the given set of sources to an array.
    *
    * @param sources the set to be converted
    * @return an array containing all of the sources in the given set
    */
   List<Source> _toArray(Set<Source> sources) {
     int size = sources.length;
@@ skipping 474 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }