Fixes to associating existing elements with an AST

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, 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.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 986 matching lines @@
     CompilationUnit libraryUnit = getRequiredInput(UNIT_INPUT_NAME);
     Map<Source, LibraryElement> importLibraryMap =
         getRequiredInput(IMPORTS_LIBRARY_ELEMENT_INPUT_NAME);
     Map<Source, LibraryElement> exportLibraryMap =
         getRequiredInput(EXPORTS_LIBRARY_ELEMENT_INPUT_NAME);
     Map<Source, SourceKind> importSourceKindMap =
         getRequiredInput(IMPORTS_SOURCE_KIND_INPUT_NAME);
     Map<Source, SourceKind> exportSourceKindMap =
         getRequiredInput(EXPORTS_SOURCE_KIND_INPUT_NAME);
     //
-    // Build elements.
+    // Try to get the existing LibraryElement.
     //
-    DirectiveElementBuilder builder = new DirectiveElementBuilder(
-        context,
-        libraryElement,
-        importLibraryMap,
-        importSourceKindMap,
-        exportLibraryMap,
-        exportSourceKindMap);
-    libraryUnit.accept(builder);
-    // See commentary in the computation of the LIBRARY_CYCLE result
-    // for details on library cycle invalidation.
-    libraryElement.invalidateLibraryCycles();
+    LibraryElement element;
+    {
+      InternalAnalysisContext internalContext =
+          context as InternalAnalysisContext;
+      AnalysisCache analysisCache = internalContext.analysisCache;
+      CacheEntry cacheEntry = internalContext.getCacheEntry(target);
+      element = analysisCache.getValue(target, LIBRARY_ELEMENT2);
+      if (element == null &&
+          internalContext.aboutToComputeResult(cacheEntry, LIBRARY_ELEMENT2)) {
+        element = analysisCache.getValue(target, LIBRARY_ELEMENT2);
+      }
+    }
+    //
+    // Build or reuse the directive elements.
+    //
+    List<AnalysisError> errors;
+    if (element == null) {
+      DirectiveElementBuilder builder = new DirectiveElementBuilder(
+          context,
+          libraryElement,
+          importLibraryMap,
+          importSourceKindMap,
+          exportLibraryMap,
+          exportSourceKindMap);
+      libraryUnit.accept(builder);
+      // See the commentary in the computation of the LIBRARY_CYCLE result
+      // for details on library cycle invalidation.
+      libraryElement.invalidateLibraryCycles();
+      errors = builder.errors;
+    } else {
+      DirectiveResolver resolver = new DirectiveResolver();
+      libraryUnit.accept(resolver);
+    }
     //
     // Record outputs.
     //
     outputs[LIBRARY_ELEMENT2] = libraryElement;
-    outputs[BUILD_DIRECTIVES_ERRORS] = builder.errors;
+    outputs[BUILD_DIRECTIVES_ERRORS] = errors;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     Source source = target;
     return <String, TaskInput>{
@@ skipping 341 matching lines @@
     }
     //
     // Create a new LibraryElement.
     //
     if (libraryElement == null) {
       libraryElement =
           new LibraryElementImpl.forNode(owningContext, libraryNameNode);
       libraryElement.definingCompilationUnit = definingCompilationUnitElement;
       libraryElement.entryPoint = entryPoint;
       libraryElement.parts = sourcedCompilationUnits;
-      for (Directive directive in directivesToResolve) {
-        directive.element = libraryElement;
-      }
+      libraryElement.hasExtUri = _hasExtUri(definingCompilationUnit);
       BuildLibraryElementUtils.patchTopLevelAccessors(libraryElement);
       // set the library documentation to the docs associated with the first
       // directive in the compilation unit.
       if (definingCompilationUnit.directives.isNotEmpty) {
         setElementDocumentationComment(
             libraryElement, definingCompilationUnit.directives.first);
       }
     }
     //
+    // Resolve the relevant directives to the library element.
+    //
+    // TODO(brianwilkerson) This updates the state of the AST structures but
+    // does not associate a new result with it.
+    //
+    for (Directive directive in directivesToResolve) {
+      directive.element = libraryElement;
+    }
+    //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
     outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
   }
 
   /**
    * Return the top-level [FunctionElement] entry point, or `null` if the given
    * [element] does not define an entry point.
@@ skipping 19 matching lines @@
         LibraryIdentifier libraryName = directive.libraryName;
         if (libraryName != null) {
           return libraryName.name;
         }
       }
     }
     return null;
   }
 
   /**
+   * Return `true` if the given compilation [unit] contains at least one
+   * import directive with a `dart-ext:` URI.
+   */
+  bool _hasExtUri(CompilationUnit unit) {
+    for (Directive directive in unit.directives) {
+      if (directive is ImportDirective) {
+        if (DartUriResolver.isDartExtUri(directive.uriContent)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [libSource].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     Source source = target;
     return <String, TaskInput>{
       DEFINING_UNIT_INPUT:
           RESOLVED_UNIT1.of(new LibrarySpecificUnit(source, source)),
       PARTS_UNIT_INPUT: INCLUDED_PARTS.of(source).toList((Source unit) {
@@ skipping 3811 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }