Add uriOffset and uriEnd to the summary.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 189 matching lines @@
             kind: PrelinkedReferenceKind.typedef,
             name: typedef.name,
             numTypeParameters: typedef.typeParameters.length));
       }
     }
     if (unitNum == 0) {
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
       }
       b.publicNamespace = encodeUnlinkedPublicNamespace(ctx,
-          exports: libraryElement.exports.map(serializeExport).toList(),
+          exports: libraryElement.exports.map(serializeExportPublic).toList(),
           parts: libraryElement.parts
-              .map((CompilationUnitElement e) =>
-                  encodeUnlinkedPart(ctx, uri: e.uri))
+              .map((CompilationUnitElement e) => e.uri)
               .toList(),
           names: names);
+      b.exports = libraryElement.exports.map(serializeExportNonPublic).toList();
       b.imports = libraryElement.imports.map(serializeImport).toList();
+      b.parts = libraryElement.parts
+          .map((CompilationUnitElement e) =>
+              encodeUnlinkedPart(ctx, uriOffset: e.uriOffset, uriEnd: e.uriEnd))
+          .toList();
     } else {
       // TODO(paulberry): we need to figure out a way to record library, part,
       // import, and export declarations that appear in non-defining
       // compilation units (even though such declarations are prohibited by the
       // language), so that if the user makes code changes that cause a
       // non-defining compilation unit to become a defining compilation unit,
       // we can create a correct summary by simply re-linking.
       b.publicNamespace = encodeUnlinkedPublicNamespace(ctx, names: names);
     }
     b.classes = element.types.map(serializeClass).toList();
@@ skipping 198 matching lines @@
     }
     b.isAbstract = executableElement.isAbstract;
     b.isStatic = executableElement.isStatic &&
         executableElement.enclosingElement is ClassElement;
     b.hasImplicitReturnType = executableElement.hasImplicitReturnType;
     b.isExternal = executableElement.isExternal;
     return b;
   }
 
   /**
-   * Serialize the given [exportElement] into an [UnlinkedExport].
+   * Serialize the given [exportElement] into an [UnlinkedExportNonPublic].
    */
-  UnlinkedExportBuilder serializeExport(ExportElement exportElement) {
-    UnlinkedExportBuilder b = new UnlinkedExportBuilder(ctx);
+  UnlinkedExportNonPublicBuilder serializeExportNonPublic(
+      ExportElement exportElement) {
+    UnlinkedExportNonPublicBuilder b = new UnlinkedExportNonPublicBuilder(ctx);
+    b.uriOffset = exportElement.uriOffset;
+    b.uriEnd = exportElement.uriEnd;
+    return b;
+  }
+
+  /**
+   * Serialize the given [exportElement] into an [UnlinkedExportPublic].
+   */
+  UnlinkedExportPublicBuilder serializeExportPublic(
+      ExportElement exportElement) {
+    UnlinkedExportPublicBuilder b = new UnlinkedExportPublicBuilder(ctx);
     b.uri = exportElement.uri;
     b.combinators = exportElement.combinators.map(serializeCombinator).toList();
     return b;
   }
 
   /**
    * Serialize the given [importElement] yielding an [UnlinkedImportBuilder].
    * Also, add pre-linked information about it to the [prelinkedImports] list.
    */
   UnlinkedImportBuilder serializeImport(ImportElement importElement) {
     UnlinkedImportBuilder b = new UnlinkedImportBuilder(ctx);
     b.isDeferred = importElement.isDeferred;
     b.offset = importElement.nameOffset;
     b.combinators = importElement.combinators.map(serializeCombinator).toList();
     if (importElement.prefix != null) {
       b.prefixReference = serializePrefix(importElement.prefix);
     }
     if (importElement.isSynthetic) {
       b.isImplicit = true;
     } else {
       b.uri = importElement.uri;
+      b.uriOffset = importElement.uriOffset;
+      b.uriEnd = importElement.uriEnd;
     }
     addTransitiveExportClosure(importElement.importedLibrary);
     prelinkedImports.add(serializeDependency(importElement.importedLibrary));
     return b;
   }
 
   /**
    * Serialize the whole library element into a [PrelinkedLibrary].  Should be
    * called exactly once for each instance of [_LibrarySerializer].
    *
@@ skipping 177 matching lines @@
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     return b;
   }
 }