Add a "librarySource" field to CompilationUnitElementImpl.

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 engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 762 matching lines @@
 }
 
 /**
  * A `CompilationUnitBuilder` builds an element model for a single compilation
  * unit.
  */
 class CompilationUnitBuilder {
   /**
    * Build the compilation unit element for the given [source] based on the
    * compilation [unit] associated with the source. Throw an AnalysisException
-   * if the element could not be built.
+   * if the element could not be built.  [librarySource] is the source for the
+   * containing library.
    */
   CompilationUnitElementImpl buildCompilationUnit(
-      Source source, CompilationUnit unit) {
+      Source source, CompilationUnit unit, Source librarySource) {
     return PerformanceStatistics.resolve.makeCurrentWhile(() {
       if (unit == null) {
         return null;
       }
       ElementHolder holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder);
       unit.accept(builder);
       CompilationUnitElementImpl element =
           new CompilationUnitElementImpl(source.shortName);
       element.accessors = holder.accessors;
       element.enums = holder.enums;
       element.functions = holder.functions;
       element.source = source;
+      element.librarySource = librarySource;
       element.typeAliases = holder.typeAliases;
       element.types = holder.types;
       element.topLevelVariables = holder.topLevelVariables;
       unit.element = element;
       holder.validate();
       return element;
     });
   }
 }
 
@@ skipping 6343 matching lines @@
    * Build the library element for the given library.
    *
    * @param library the library for which an element model is to be built
    * @return the library element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElementImpl buildLibrary(Library library) {
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
     Source librarySource = library.librarySource;
     CompilationUnit definingCompilationUnit = library.definingCompilationUnit;
-    CompilationUnitElementImpl definingCompilationUnitElement =
-        builder.buildCompilationUnit(librarySource, definingCompilationUnit);
+    CompilationUnitElementImpl definingCompilationUnitElement = builder
+        .buildCompilationUnit(
+            librarySource, definingCompilationUnit, librarySource);
     NodeList<Directive> directives = definingCompilationUnit.directives;
     LibraryIdentifier libraryNameNode = null;
     bool hasPartDirective = false;
     FunctionElement entryPoint =
         _findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = new List<Directive>();
     List<CompilationUnitElementImpl> sourcedCompilationUnits =
         new List<CompilationUnitElementImpl>();
     for (Directive directive in directives) {
       //
       // We do not build the elements representing the import and export
       // directives at this point. That is not done until we get to
       // LibraryResolver.buildDirectiveModels() because we need the
       // LibraryElements for the referenced libraries, which might not exist at
       // this point (due to the possibility of circular references).
       //
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
         Source partSource = partDirective.source;
         if (_analysisContext.exists(partSource)) {
           hasPartDirective = true;
           CompilationUnit partUnit = library.getAST(partSource);
           CompilationUnitElementImpl part =
-              builder.buildCompilationUnit(partSource, partUnit);
+              builder.buildCompilationUnit(partSource, partUnit, librarySource);
           part.uriOffset = partUri.offset;
           part.uriEnd = partUri.end;
           part.uri = partDirective.uriContent;
           //
           // Validate that the part contains a part-of directive with the same
           // name as the library.
           //
           String partLibraryName =
               _getPartLibraryName(partSource, partUnit, directivesToResolve);
           if (partLibraryName == null) {
@@ skipping 50 matching lines @@
    * Build the library element for the given library.  The resulting element is
    * stored in the [ResolvableLibrary] structure.
    *
    * @param library the library for which an element model is to be built
    * @throws AnalysisException if the analysis could not be performed
    */
   void buildLibrary2(ResolvableLibrary library) {
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
     Source librarySource = library.librarySource;
     CompilationUnit definingCompilationUnit = library.definingCompilationUnit;
-    CompilationUnitElementImpl definingCompilationUnitElement =
-        builder.buildCompilationUnit(librarySource, definingCompilationUnit);
+    CompilationUnitElementImpl definingCompilationUnitElement = builder
+        .buildCompilationUnit(
+            librarySource, definingCompilationUnit, librarySource);
     NodeList<Directive> directives = definingCompilationUnit.directives;
     LibraryIdentifier libraryNameNode = null;
     bool hasPartDirective = false;
     FunctionElement entryPoint =
         _findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = new List<Directive>();
     List<CompilationUnitElementImpl> sourcedCompilationUnits =
         new List<CompilationUnitElementImpl>();
     for (Directive directive in directives) {
       //
       // We do not build the elements representing the import and export
       // directives at this point. That is not done until we get to
       // LibraryResolver.buildDirectiveModels() because we need the
       // LibraryElements for the referenced libraries, which might not exist at
       // this point (due to the possibility of circular references).
       //
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
         Source partSource = partDirective.source;
         if (_analysisContext.exists(partSource)) {
           hasPartDirective = true;
           CompilationUnit partUnit = library.getAST(partSource);
           if (partUnit != null) {
-            CompilationUnitElementImpl part =
-                builder.buildCompilationUnit(partSource, partUnit);
+            CompilationUnitElementImpl part = builder.buildCompilationUnit(
+                partSource, partUnit, librarySource);
             part.uriOffset = partUri.offset;
             part.uriEnd = partUri.end;
             part.uri = partDirective.uriContent;
             //
             // Validate that the part contains a part-of directive with the same
             // name as the library.
             //
             String partLibraryName =
                 _getPartLibraryName(partSource, partUnit, directivesToResolve);
             if (partLibraryName == null) {
@@ skipping 8143 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }