Add Element.nameOffset and LibraryElement.nameLength to summaries.

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 187 matching lines @@
       if (typedef.isPublic) {
         names.add(encodeUnlinkedPublicName(ctx,
             kind: PrelinkedReferenceKind.typedef,
             name: typedef.name,
             numTypeParameters: typedef.typeParameters.length));
       }
     }
     if (unitNum == 0) {
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
+        b.libraryNameOffset = libraryElement.nameOffset;
+        b.libraryNameLength = libraryElement.nameLength;
       }
       b.publicNamespace = encodeUnlinkedPublicNamespace(ctx,
           exports: libraryElement.exports.map(serializeExportPublic).toList(),
           parts: libraryElement.parts
               .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
@@ skipping 82 matching lines @@
     }
     throw new StateError('Unbound type parameter $type');
   }
 
   /**
    * Serialize the given [classElement], creating an [UnlinkedClass].
    */
   UnlinkedClassBuilder serializeClass(ClassElement classElement) {
     UnlinkedClassBuilder b = new UnlinkedClassBuilder(ctx);
     b.name = classElement.name;
+    b.nameOffset = classElement.nameOffset;
     b.typeParameters =
         classElement.typeParameters.map(serializeTypeParam).toList();
     if (classElement.supertype == null) {
       b.hasNoSupertype = true;
     } else if (!classElement.supertype.isObject) {
       b.supertype = serializeTypeRef(classElement.supertype, classElement);
     }
     b.mixins = classElement.mixins
         .map((InterfaceType t) => serializeTypeRef(t, classElement))
         .toList();
@@ skipping 61 matching lines @@
    * representing the pseudo-type `dynamic`.
    */
   int serializeDynamicReference() => 0;
 
   /**
    * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
   UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder(ctx);
     b.name = enumElement.name;
+    b.nameOffset = enumElement.nameOffset;
     List<UnlinkedEnumValueBuilder> values = <UnlinkedEnumValueBuilder>[];
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
-        values.add(encodeUnlinkedEnumValue(ctx, name: field.name));
+        values.add(encodeUnlinkedEnumValue(ctx,
+            name: field.name, nameOffset: field.nameOffset));
       }
     }
     b.values = values;
     return b;
   }
 
   /**
    * Serialize the given [executableElement], creating an [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       ExecutableElement executableElement) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder(ctx);
     b.name = executableElement.name;
+    b.nameOffset = executableElement.nameOffset;
     if (executableElement is! ConstructorElement &&
         !executableElement.type.returnType.isVoid) {
       b.returnType = serializeTypeRef(
           executableElement.type.returnType, executableElement);
     }
     b.typeParameters =
         executableElement.typeParameters.map(serializeTypeParam).toList();
     b.parameters =
         executableElement.type.parameters.map(serializeParam).toList();
     if (executableElement is PropertyAccessorElement) {
@@ skipping 16 matching lines @@
     b.isExternal = executableElement.isExternal;
     return b;
   }
 
   /**
    * Serialize the given [exportElement] into an [UnlinkedExportNonPublic].
    */
   UnlinkedExportNonPublicBuilder serializeExportNonPublic(
       ExportElement exportElement) {
     UnlinkedExportNonPublicBuilder b = new UnlinkedExportNonPublicBuilder(ctx);
+    b.offset = exportElement.nameOffset;
     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);
+      b.prefixOffset = importElement.prefix.nameOffset;
     }
     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));
@@ skipping 20 matching lines @@
   }
 
   /**
    * Serialize the given [parameter] into an [UnlinkedParam].
    */
   UnlinkedParamBuilder serializeParam(ParameterElement parameter,
       [Element context]) {
     context ??= parameter;
     UnlinkedParamBuilder b = new UnlinkedParamBuilder(ctx);
     b.name = parameter.name;
+    b.nameOffset = parameter.nameOffset;
     switch (parameter.parameterKind) {
       case ParameterKind.REQUIRED:
         b.kind = UnlinkedParamKind.required;
         break;
       case ParameterKind.POSITIONAL:
         b.kind = UnlinkedParamKind.positional;
         break;
       case ParameterKind.NAMED:
         b.kind = UnlinkedParamKind.named;
         break;
@@ skipping 29 matching lines @@
     });
   }
 
   /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder(ctx);
     b.name = typedefElement.name;
+    b.nameOffset = typedefElement.nameOffset;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     if (!typedefElement.returnType.isVoid) {
       b.returnType =
           serializeTypeRef(typedefElement.returnType, typedefElement);
     }
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
     return b;
   }
 
   /**
    * Serialize the given [typeParameter] into an [UnlinkedTypeParam].
    */
   UnlinkedTypeParamBuilder serializeTypeParam(
       TypeParameterElement typeParameter) {
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder(ctx);
     b.name = typeParameter.name;
+    b.nameOffset = typeParameter.nameOffset;
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     return b;
   }
 
   /**
    * Serialize the given [type] into an [UnlinkedTypeRef].
    */
   UnlinkedTypeRefBuilder serializeTypeRef(DartType type, Element context) {
@@ skipping 70 matching lines @@
     }
     return unresolvedReferenceIndex;
   }
 
   /**
    * Serialize the given [variable], creating an [UnlinkedVariable].
    */
   UnlinkedVariableBuilder serializeVariable(PropertyInducingElement variable) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
+    b.nameOffset = variable.nameOffset;
     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;
   }
 }