Resynthesize codeOffset/codeLength properties.

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 'dart:convert';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 351 matching lines @@
     } 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.
       unlinkedUnit.publicNamespace =
           new UnlinkedPublicNamespaceBuilder(names: names);
     }
+    serializeCodeRange(unlinkedUnit, compilationUnit);
     unlinkedUnit.classes = compilationUnit.types.map(serializeClass).toList();
     unlinkedUnit.enums = compilationUnit.enums.map(serializeEnum).toList();
     unlinkedUnit.typedefs =
         compilationUnit.functionTypeAliases.map(serializeTypedef).toList();
     List<UnlinkedExecutableBuilder> executables =
         compilationUnit.functions.map(serializeExecutable).toList();
     for (PropertyAccessorElement accessor in compilationUnit.accessors) {
       if (!accessor.isSynthetic) {
         executables.add(serializeExecutable(accessor));
       }
@@ skipping 148 matching lines @@
           fields.add(serializeVariable(field));
         }
       }
     }
     b.fields = fields;
     b.executables = executables;
     b.isAbstract = classElement.isAbstract;
     b.isMixinApplication = classElement.isMixinApplication;
     b.documentationComment = serializeDocumentation(classElement);
     b.annotations = serializeAnnotations(classElement);
+    serializeCodeRange(b, classElement);
     return b;
   }
 
   /**
    * If [cls] is a class, return the list of its members available for
    * constants - static constant fields, static methods and constructors.
    * Otherwise return `null`.
    */
   List<UnlinkedPublicNameBuilder> serializeClassConstMembers(ClassElement cls) {
     if (cls.isMixinApplication) {
@@ skipping 29 matching lines @@
               name: constructor.name,
               kind: ReferenceKind.constructor,
               numTypeParameters: 0));
         }
       }
       return bs;
     }
     return null;
   }
 
+  void serializeCodeRange(Object b, Element element) {
+    if (element is ElementImpl && element.codeOffset != null) {
+      if (b is UnlinkedClassBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedEnumBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedExecutableBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedParamBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedTypedefBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedTypeParamBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedUnitBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      } else if (b is UnlinkedVariableBuilder) {
+        b.hasCodeRange = true;
+        b.codeOffset = element.codeOffset;
+        b.codeLength = element.codeLength;
+      }
+    }
+  }
+
   /**
    * Serialize the given [combinator] into an [UnlinkedCombinator].
    */
   UnlinkedCombinatorBuilder serializeCombinator(
       NamespaceCombinator combinator) {
     UnlinkedCombinatorBuilder b = new UnlinkedCombinatorBuilder();
     if (combinator is ShowElementCombinator) {
       b.shows = combinator.shownNames;
       b.offset = combinator.offset;
       b.end = combinator.end;
@@ skipping 42 matching lines @@
       if (field.isConst && field.type.element == enumElement) {
         values.add(new UnlinkedEnumValueBuilder(
             name: field.name,
             nameOffset: field.nameOffset,
             documentationComment: serializeDocumentation(field)));
       }
     }
     b.values = values;
     b.documentationComment = serializeDocumentation(enumElement);
     b.annotations = serializeAnnotations(enumElement);
+    serializeCodeRange(b, enumElement);
     return b;
   }
 
   /**
    * Serialize the given [executableElement], creating an [UnlinkedExecutable].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       ExecutableElement executableElement) {
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder();
     b.name = executableElement.name;
@@ skipping 68 matching lines @@
       }
     } else {
       b.kind = UnlinkedExecutableKind.functionOrMethod;
     }
     b.isAbstract = executableElement.isAbstract;
     b.isStatic = executableElement.isStatic &&
         executableElement.enclosingElement is ClassElement;
     b.isExternal = executableElement.isExternal;
     b.documentationComment = serializeDocumentation(executableElement);
     b.annotations = serializeAnnotations(executableElement);
+    serializeCodeRange(b, executableElement);
     if (executableElement is FunctionElement) {
       SourceRange visibleRange = executableElement.visibleRange;
       if (visibleRange != null) {
         b.visibleOffset = visibleRange.offset;
         b.visibleLength = visibleRange.length;
       }
     }
     b.localFunctions =
         executableElement.functions.map(serializeExecutable).toList();
     b.localLabels = executableElement.labels.map(serializeLabel).toList();
@@ skipping 76 matching lines @@
         b.kind = UnlinkedParamKind.required;
         break;
       case ParameterKind.POSITIONAL:
         b.kind = UnlinkedParamKind.positional;
         break;
       case ParameterKind.NAMED:
         b.kind = UnlinkedParamKind.named;
         break;
     }
     b.annotations = serializeAnnotations(parameter);
+    serializeCodeRange(b, parameter);
     b.isInitializingFormal = parameter.isInitializingFormal;
     DartType type = parameter.type;
     if (parameter.hasImplicitType) {
       Element contextParent = context.enclosingElement;
       if (!parameter.isInitializingFormal &&
           contextParent is ExecutableElement &&
           !contextParent.isStatic &&
           contextParent is! ConstructorElement) {
         b.inferredTypeSlot = storeInferredType(type, context);
       }
@@ skipping 69 matching lines @@
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = typedefElement.name;
     b.nameOffset = typedefElement.nameOffset;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     b.returnType = serializeTypeRef(typedefElement.returnType, typedefElement);
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
     b.documentationComment = serializeDocumentation(typedefElement);
     b.annotations = serializeAnnotations(typedefElement);
+    serializeCodeRange(b, typedefElement);
     return b;
   }
 
   /**
    * Serialize the given [typeParameter] into an [UnlinkedTypeParam].
    */
   UnlinkedTypeParamBuilder serializeTypeParam(
       TypeParameterElement typeParameter) {
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder();
     b.name = typeParameter.name;
     b.nameOffset = typeParameter.nameOffset;
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     b.annotations = serializeAnnotations(typeParameter);
+    serializeCodeRange(b, typeParameter);
     return b;
   }
 
   /**
    * Serialize the given [type] into a [EntityRef].  If [slot] is provided,
    * it should be included in the [EntityRef].
    *
    * [context] is the element within which the [EntityRef] will be
    * interpreted; this is used to serialize type parameters.
    */
@@ skipping 129 matching lines @@
             storeLinkedType(variable.propagatedType, variable);
       } else {
         // Variable is not propagable.
         assert(variable.propagatedType == null);
       }
     }
     if (variable.hasImplicitType &&
         (variable.initializer != null || !variable.isStatic)) {
       b.inferredTypeSlot = storeInferredType(variable.type, variable);
     }
+    serializeCodeRange(b, variable);
     if (variable is LocalVariableElement) {
       SourceRange visibleRange = variable.visibleRange;
       if (visibleRange != null) {
         b.visibleOffset = visibleRange.offset;
         b.visibleLength = visibleRange.length;
       }
     }
     // TODO(scheglov) VariableMember.initializer is not implemented
     if (variable is! VariableMember && variable.initializer != null) {
       b.initializer = serializeExecutable(variable.initializer);
     }
     return b;
   }
 
   /**
+   * Create a new slot id and return it.  If [hasCycle] is `true`, arrange for
+   * the slot id to be included in [LinkedUnit.constCycles].
+   */
+  int storeConstCycle(bool hasCycle) {
+    int slot = ++numSlots;
+    if (hasCycle) {
+      constCycles.add(slot);
+    }
+    return slot;
+  }
+
+  /**
    * Create a slot id for the given [type] (which is an inferred type).  If
    * [type] is not `dynamic`, it is stored in [linkedTypes] so that once the
    * compilation unit has been fully visited, it will be serialized into
    * [LinkedUnit.types].
    *
    * [context] is the element within which the slot id will appear; this is
    * used to serialize type parameters.
    */
   int storeInferredType(DartType type, Element context) {
     return storeLinkedType(type.isDynamic ? null : type, context);
   }
 
   /**
-   * Create a new slot id and return it.  If [hasCycle] is `true`, arrange for
-   * the slot id to be included in [LinkedUnit.constCycles].
-   */
-  int storeConstCycle(bool hasCycle) {
-    int slot = ++numSlots;
-    if (hasCycle) {
-      constCycles.add(slot);
-    }
-    return slot;
-  }
-
-  /**
    * Create a slot id for the given [type] (which may be either a propagated
    * type or an inferred type).  If [type] is not `null`, it is stored in
    * [linkedTypes] so that once the compilation unit has been fully visited,
    * it will be serialized to [LinkedUnit.types].
    *
    * [context] is the element within which the slot id will appear; this is
    * used to serialize type parameters.
    */
   int storeLinkedType(DartType type, Element context) {
     int slot = ++numSlots;
@@ skipping 426 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }