Add Element.nameOffset and LibraryElement.nameLength to summaries.

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 215 matching lines @@
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     try {
       currentTypeParameters =
           serializedClass.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedClass.typeParameters.length; i++) {
         finishTypeParameter(
             serializedClass.typeParameters[i], currentTypeParameters[i]);
       }
-      ClassElementImpl classElement =
-          new ClassElementImpl(serializedClass.name, -1);
+      ClassElementImpl classElement = new ClassElementImpl(
+          serializedClass.name, serializedClass.nameOffset);
       classElement.mixinApplication = serializedClass.isMixinApplication;
       InterfaceTypeImpl correspondingType = new InterfaceTypeImpl(classElement);
       if (serializedClass.supertype != null) {
         classElement.supertype = buildType(serializedClass.supertype);
       } else if (!serializedClass.hasNoSupertype) {
         if (isCoreLibrary) {
           delayedObjectSubclasses.add(classElement);
         } else {
           classElement.supertype = summaryResynthesizer.typeProvider.objectType;
         }
@@ skipping 66 matching lines @@
   }
 
   /**
    * Resynthesize a [ConstructorElement] and place it in the given [holder].
    * [classType] is the type of the class for which this element is a
    * constructor.
    */
   void buildConstructor(UnlinkedExecutable serializedExecutable,
       ElementHolder holder, InterfaceType classType) {
     assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
-    ConstructorElementImpl constructorElement =
-        new ConstructorElementImpl(serializedExecutable.name, -1);
+    ConstructorElementImpl constructorElement = new ConstructorElementImpl(
+        serializedExecutable.name, serializedExecutable.nameOffset);
     constructorElement.returnType = classType;
     buildExecutableCommonParts(constructorElement, serializedExecutable);
     constructorElement.factory = serializedExecutable.isFactory;
     constructorElement.const2 = serializedExecutable.isConst;
     holder.addConstructor(constructorElement);
   }
 
   /**
    * Resynthesize the [ClassElement] corresponding to an enum, along with the
    * associated fields and implicit accessors.
    */
   void buildEnum(UnlinkedEnum serializedEnum) {
     assert(!isCoreLibrary);
     // TODO(paulberry): add offset support (for this element type and others)
     ClassElementImpl classElement =
-        new ClassElementImpl(serializedEnum.name, -1);
+        new ClassElementImpl(serializedEnum.name, serializedEnum.nameOffset);
     classElement.enum2 = true;
     InterfaceType enumType = new InterfaceTypeImpl(classElement);
     classElement.type = enumType;
     classElement.supertype = summaryResynthesizer.typeProvider.objectType;
     ElementHolder memberHolder = new ElementHolder();
     FieldElementImpl indexField = new FieldElementImpl('index', -1);
     indexField.final2 = true;
     indexField.synthetic = true;
     indexField.type = summaryResynthesizer.typeProvider.intType;
     memberHolder.addField(indexField);
     buildImplicitAccessors(indexField, memberHolder);
     FieldElementImpl valuesField = new ConstFieldElementImpl('values', -1);
     valuesField.synthetic = true;
     valuesField.const3 = true;
     valuesField.static = true;
     valuesField.type = summaryResynthesizer.typeProvider.listType
         .substitute4(<DartType>[enumType]);
     memberHolder.addField(valuesField);
     buildImplicitAccessors(valuesField, memberHolder);
     for (UnlinkedEnumValue serializedEnumValue in serializedEnum.values) {
-      ConstFieldElementImpl valueField =
-          new ConstFieldElementImpl(serializedEnumValue.name, -1);
+      ConstFieldElementImpl valueField = new ConstFieldElementImpl(
+          serializedEnumValue.name, serializedEnumValue.nameOffset);
       valueField.const3 = true;
       valueField.static = true;
       valueField.type = enumType;
       memberHolder.addField(valueField);
       buildImplicitAccessors(valueField, memberHolder);
     }
     classElement.fields = memberHolder.fields;
     classElement.accessors = memberHolder.accessors;
     classElement.constructors = <ConstructorElement>[];
     unitHolder.addEnum(classElement);
@@ skipping 11 matching lines @@
     UnlinkedExecutableKind kind = serializedExecutable.kind;
     String name = serializedExecutable.name;
     if (kind == UnlinkedExecutableKind.setter) {
       assert(name.endsWith('='));
       name = name.substring(0, name.length - 1);
     }
     switch (kind) {
       case UnlinkedExecutableKind.functionOrMethod:
         if (isTopLevel) {
           FunctionElementImpl executableElement =
-              new FunctionElementImpl(name, -1);
+              new FunctionElementImpl(name, serializedExecutable.nameOffset);
           buildExecutableCommonParts(executableElement, serializedExecutable);
           holder.addFunction(executableElement);
         } else {
-          MethodElementImpl executableElement = new MethodElementImpl(name, -1);
+          MethodElementImpl executableElement =
+              new MethodElementImpl(name, serializedExecutable.nameOffset);
           buildExecutableCommonParts(executableElement, serializedExecutable);
           executableElement.static = serializedExecutable.isStatic;
           holder.addMethod(executableElement);
         }
         break;
       case UnlinkedExecutableKind.getter:
       case UnlinkedExecutableKind.setter:
         PropertyAccessorElementImpl executableElement =
-            new PropertyAccessorElementImpl(name, -1);
+            new PropertyAccessorElementImpl(
+                name, serializedExecutable.nameOffset);
         if (isTopLevel) {
           executableElement.static = true;
         } else {
           executableElement.static = serializedExecutable.isStatic;
         }
         buildExecutableCommonParts(executableElement, serializedExecutable);
         DartType type;
         if (kind == UnlinkedExecutableKind.getter) {
           executableElement.getter = true;
           type = executableElement.returnType;
@@ skipping 60 matching lines @@
     executableElement.external = serializedExecutable.isExternal;
     currentTypeParameters.removeRange(
         oldTypeParametersLength, currentTypeParameters.length);
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
   ExportElement buildExport(UnlinkedExportPublic serializedExportPublic,
       UnlinkedExportNonPublic serializedExportNonPublic) {
-    ExportElementImpl exportElement = new ExportElementImpl(0);
+    ExportElementImpl exportElement =
+        new ExportElementImpl(serializedExportNonPublic.offset);
     String exportedLibraryUri = summaryResynthesizer.sourceFactory
         .resolveUri(librarySource, serializedExportPublic.uri)
         .uri
         .toString();
     exportElement.exportedLibrary = new LibraryElementHandle(
         summaryResynthesizer,
         new ElementLocationImpl.con3(<String>[exportedLibraryUri]));
     exportElement.uri = serializedExportPublic.uri;
     exportElement.combinators =
         serializedExportPublic.combinators.map(buildCombinator).toList();
@@ skipping 15 matching lines @@
 
   /**
    * Build the implicit getter and setter associated with [element], and place
    * them in [holder].
    */
   void buildImplicitAccessors(
       PropertyInducingElementImpl element, ElementHolder holder) {
     String name = element.name;
     DartType type = element.type;
     PropertyAccessorElementImpl getter =
-        new PropertyAccessorElementImpl(name, -1);
+        new PropertyAccessorElementImpl(name, element.nameOffset);
     getter.getter = true;
     getter.static = element.isStatic;
     getter.synthetic = true;
     getter.returnType = type;
     getter.type = new FunctionTypeImpl(getter);
     getter.variable = element;
     getter.hasImplicitReturnType = element.hasImplicitType;
     holder.addAccessor(getter);
     element.getter = getter;
     if (!(element.isConst || element.isFinal)) {
       PropertyAccessorElementImpl setter =
-          new PropertyAccessorElementImpl(name, -1);
+          new PropertyAccessorElementImpl(name, element.nameOffset);
       setter.setter = true;
       setter.static = element.isStatic;
       setter.synthetic = true;
       setter.parameters = <ParameterElement>[
-        new ParameterElementImpl('_$name', -1)
+        new ParameterElementImpl('_$name', element.nameOffset)
           ..synthetic = true
           ..type = type
           ..parameterKind = ParameterKind.REQUIRED
       ];
       setter.returnType = VoidTypeImpl.instance;
       setter.type = new FunctionTypeImpl(setter);
       setter.variable = element;
       holder.addAccessor(setter);
       element.setter = setter;
     }
@@ skipping 61 matching lines @@
     if (isSynthetic) {
       importElement.synthetic = true;
     } else {
       importElement.uri = serializedImport.uri;
       importElement.uriOffset = serializedImport.uriOffset;
       importElement.uriEnd = serializedImport.uriEnd;
     }
     if (serializedImport.prefixReference != 0) {
       UnlinkedReference serializedPrefix =
           unlinkedUnits[0].references[serializedImport.prefixReference];
-      importElement.prefix = new PrefixElementImpl(serializedPrefix.name, -1);
+      importElement.prefix = new PrefixElementImpl(
+          serializedPrefix.name, serializedImport.prefixOffset);
     }
     importElement.combinators =
         serializedImport.combinators.map(buildCombinator).toList();
     return importElement;
   }
 
   /**
    * Main entry point.  Resynthesize the [LibraryElement] and return it.
    */
   LibraryElement buildLibrary() {
-    // TODO(paulberry): is it ok to pass -1 for offset and nameLength?
+    bool hasName = unlinkedUnits[0].libraryName.isNotEmpty;
     LibraryElementImpl libraryElement = new LibraryElementImpl(
-        summaryResynthesizer.context, unlinkedUnits[0].libraryName, -1, -1);
+        summaryResynthesizer.context,
+        unlinkedUnits[0].libraryName,
+        hasName ? unlinkedUnits[0].libraryNameOffset : -1,
+        unlinkedUnits[0].libraryNameLength);
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl(librarySource.shortName);
     libraryElement.definingCompilationUnit = definingCompilationUnit;
     definingCompilationUnit.source = librarySource;
     definingCompilationUnit.librarySource = librarySource;
     List<CompilationUnitElement> parts = <CompilationUnitElement>[];
     UnlinkedUnit unlinkedDefiningUnit = unlinkedUnits[0];
     assert(unlinkedDefiningUnit.publicNamespace.parts.length + 1 ==
         prelinkedLibrary.units.length);
     for (int i = 1; i < prelinkedLibrary.units.length; i++) {
@@ skipping 29 matching lines @@
         classElement.supertype = objectElement.type;
       }
     }
     return libraryElement;
   }
 
   /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(UnlinkedParam serializedParameter) {
-    ParameterElementImpl parameterElement =
-        new ParameterElementImpl(serializedParameter.name, -1);
+    ParameterElementImpl parameterElement = new ParameterElementImpl(
+        serializedParameter.name, serializedParameter.nameOffset);
     if (serializedParameter.isFunctionTyped) {
       FunctionElementImpl parameterTypeElement =
           new FunctionElementImpl('', -1);
       parameterTypeElement.synthetic = true;
       parameterElement.parameters =
           serializedParameter.parameters.map(buildParameter).toList();
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
       if (serializedParameter.type != null) {
         parameterTypeElement.returnType = buildType(serializedParameter.type);
@@ skipping 137 matching lines @@
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     try {
       currentTypeParameters =
           serializedTypedef.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedTypedef.typeParameters.length; i++) {
         finishTypeParameter(
             serializedTypedef.typeParameters[i], currentTypeParameters[i]);
       }
       FunctionTypeAliasElementImpl functionTypeAliasElement =
-          new FunctionTypeAliasElementImpl(serializedTypedef.name, -1);
+          new FunctionTypeAliasElementImpl(
+              serializedTypedef.name, serializedTypedef.nameOffset);
       functionTypeAliasElement.parameters =
           serializedTypedef.parameters.map(buildParameter).toList();
       if (serializedTypedef.returnType != null) {
         functionTypeAliasElement.returnType =
             buildType(serializedTypedef.returnType);
       } else {
         functionTypeAliasElement.returnType = VoidTypeImpl.instance;
       }
       functionTypeAliasElement.type =
           new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
       functionTypeAliasElement.typeParameters = currentTypeParameters;
       unitHolder.addTypeAlias(functionTypeAliasElement);
     } finally {
       currentTypeParameters = <TypeParameterElement>[];
     }
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
    * its bound.
    *
    * The bound is deferred until later since it may refer to other type
    * parameters that have not been resynthesized yet.  To handle the bound,
    * call [finishTypeParameter].
    */
   TypeParameterElement buildTypeParameter(
       UnlinkedTypeParam serializedTypeParameter) {
     TypeParameterElementImpl typeParameterElement =
-        new TypeParameterElementImpl(serializedTypeParameter.name, -1);
+        new TypeParameterElementImpl(
+            serializedTypeParameter.name, serializedTypeParameter.nameOffset);
     typeParameterElement.type = new TypeParameterTypeImpl(typeParameterElement);
     return typeParameterElement;
   }
 
   /**
    * Resynthesize a [TopLevelVariableElement] or [FieldElement].
    */
   void buildVariable(UnlinkedVariable serializedVariable,
       [ElementHolder holder]) {
     if (holder == null) {
-      TopLevelVariableElementImpl element =
-          new TopLevelVariableElementImpl(serializedVariable.name, -1);
+      TopLevelVariableElementImpl element = new TopLevelVariableElementImpl(
+          serializedVariable.name, serializedVariable.nameOffset);
       buildVariableCommonParts(element, serializedVariable);
       unitHolder.addTopLevelVariable(element);
       buildImplicitAccessors(element, unitHolder);
     } else {
-      FieldElementImpl element =
-          new FieldElementImpl(serializedVariable.name, -1);
+      FieldElementImpl element = new FieldElementImpl(
+          serializedVariable.name, serializedVariable.nameOffset);
       buildVariableCommonParts(element, serializedVariable);
       element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
     }
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
@@ skipping 49 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
   }
 }