Resynthesize codeOffset/codeLength properties.

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 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1002 matching lines @@
       }
       classElement.constructors = memberHolder.constructors;
     }
     classElement.accessors = memberHolder.accessors;
     classElement.fields = memberHolder.fields;
     classElement.methods = memberHolder.methods;
     correspondingType.typeArguments = getCurrentTypeArguments();
     classElement.type = correspondingType;
     buildDocumentation(classElement, serializedClass.documentationComment);
     buildAnnotations(classElement, serializedClass.annotations);
+    buildCodeRange(classElement, serializedClass);
     resolveConstructorInitializers(classElement);
     unitHolder.addType(classElement);
     currentTypeParameters.removeLast();
     assert(currentTypeParameters.isEmpty);
     fields = null;
     constructors = null;
   }
 
+  void buildCodeRange(ElementImpl element, Object summary) {
+    int offset;
+    int length;
+    if (summary is UnlinkedClass) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedEnum) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedExecutable) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedParam) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedTypedef) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedTypeParam) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedUnit) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    } else if (summary is UnlinkedVariable) {
+      if (summary.hasCodeRange) {
+        offset = summary.codeOffset;
+        length = summary.codeLength;
+      }
+    }
+    if (offset != null) {
+      element.setCodeRange(offset, length);
+    }
+  }
+
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
     if (serializedCombinator.shows.isNotEmpty) {
       ShowElementCombinatorImpl combinator = new ShowElementCombinatorImpl();
       // Note: we call toList() so that we don't retain a reference to the
       // deserialized data structure.
       combinator.shownNames = serializedCombinator.shows.toList();
       combinator.offset = serializedCombinator.offset;
@@ skipping 103 matching lines @@
   void buildEnum(UnlinkedEnum serializedEnum) {
     assert(!isCoreLibrary);
     ClassElementImpl classElement =
         new ClassElementImpl(serializedEnum.name, serializedEnum.nameOffset);
     classElement.enum2 = true;
     InterfaceType enumType = new InterfaceTypeImpl(classElement);
     classElement.type = enumType;
     classElement.supertype = summaryResynthesizer.typeProvider.objectType;
     buildDocumentation(classElement, serializedEnum.documentationComment);
     buildAnnotations(classElement, serializedEnum.annotations);
+    buildCodeRange(classElement, serializedEnum);
     ElementHolder memberHolder = new ElementHolder();
     // Build the 'index' field.
     FieldElementImpl indexField = new FieldElementImpl('index', -1);
     indexField.final2 = true;
     indexField.synthetic = true;
     indexField.type = summaryResynthesizer.typeProvider.intType;
     memberHolder.addField(indexField);
     buildImplicitAccessors(indexField, memberHolder);
     // Build the 'values' field.
     FieldElementImpl valuesField = new ConstFieldElementImpl('values', -1);
@@ skipping 135 matching lines @@
                   defaultVoid: isSetter && summaryResynthesizer.strongMode);
       executableElement.hasImplicitReturnType =
           serializedExecutable.returnType == null;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, getCurrentTypeArguments(skipLevels: 1), false);
     executableElement.external = serializedExecutable.isExternal;
     buildDocumentation(
         executableElement, serializedExecutable.documentationComment);
     buildAnnotations(executableElement, serializedExecutable.annotations);
+    buildCodeRange(executableElement, serializedExecutable);
     executableElement.functions =
         serializedExecutable.localFunctions.map(buildLocalFunction).toList();
     executableElement.labels =
         serializedExecutable.localLabels.map(buildLocalLabel).toList();
     executableElement.localVariables =
         serializedExecutable.localVariables.map(buildLocalVariable).toList();
     currentTypeParameters.removeLast();
   }
 
   /**
@@ skipping 381 matching lines @@
         if (serializedParameter.defaultValue != null) {
           defaultParameter.constantInitializer =
               _buildConstExpression(serializedParameter.defaultValue);
           defaultParameter.defaultValueCode =
               serializedParameter.defaultValueCode;
         }
       }
     }
     parameterElement.synthetic = synthetic;
     buildAnnotations(parameterElement, serializedParameter.annotations);
+    buildCodeRange(parameterElement, serializedParameter);
     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);
       parameterTypeElement.returnType = buildType(serializedParameter.type);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
@@ skipping 113 matching lines @@
         buildTypeParameters(serializedTypedef.typeParameters);
     functionTypeAliasElement.parameters =
         serializedTypedef.parameters.map(buildParameter).toList();
     functionTypeAliasElement.returnType =
         buildType(serializedTypedef.returnType);
     functionTypeAliasElement.type =
         new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
     buildDocumentation(
         functionTypeAliasElement, serializedTypedef.documentationComment);
     buildAnnotations(functionTypeAliasElement, serializedTypedef.annotations);
+    buildCodeRange(functionTypeAliasElement, serializedTypedef);
     unitHolder.addTypeAlias(functionTypeAliasElement);
     currentTypeParameters.removeLast();
     assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * 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, serializedTypeParameter.nameOffset);
     typeParameterElement.type = new TypeParameterTypeImpl(typeParameterElement);
     buildAnnotations(typeParameterElement, serializedTypeParameter.annotations);
+    buildCodeRange(typeParameterElement, serializedTypeParameter);
     return typeParameterElement;
   }
 
   /**
    * Build [TypeParameterElement]s corresponding to the type parameters in
    * [serializedTypeParameters] and store them in [currentTypeParameters].
    * Also return them.
    */
   List<TypeParameterElement> buildTypeParameters(
       List<UnlinkedTypeParam> serializedTypeParameters) {
@@ skipping 53 matching lines @@
   void buildVariableCommonParts(
       VariableElementImpl element, UnlinkedVariable serializedVariable) {
     element.type = buildLinkedType(serializedVariable.inferredTypeSlot) ??
         buildType(serializedVariable.type);
     element.const3 = serializedVariable.isConst;
     element.final2 = serializedVariable.isFinal;
     element.hasImplicitType = serializedVariable.type == null;
     buildVariableInitializer(element, serializedVariable.initializer);
     buildDocumentation(element, serializedVariable.documentationComment);
     buildAnnotations(element, serializedVariable.annotations);
+    buildCodeRange(element, serializedVariable);
   }
 
   /**
    * If the given [serializedInitializer] is not `null`, create the
    * corresponding [FunctionElementImpl] and set it for the [variable].
    */
   void buildVariableInitializer(
       VariableElementImpl variable, UnlinkedExecutable serializedInitializer) {
     if (serializedInitializer == null) {
       return null;
     }
     FunctionElementImpl initializerElement =
         buildLocalFunction(serializedInitializer);
     initializerElement.synthetic = true;
+    initializerElement.setCodeRange(null, null);
     variable.initializer = initializerElement;
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
@@ skipping 237 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     for (FunctionElement function in unit.functions) {
       elementMap[function.name] = function;
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
+    buildCodeRange(unit, unlinkedUnit);
     resynthesizedUnits[absoluteUri] = unit;
     resynthesizedElements[absoluteUri] = elementMap;
     assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Set up data structures for deserializing a compilation unit.
    */
   void prepareUnit(CompilationUnitElementImpl unit, int unitNum) {
     linkedUnit = linkedLibrary.units[unitNum];
@@ skipping 240 matching lines @@
     List<DartType> typeArguments = const <DartType>[];
     if (numTypeArguments != 0) {
       typeArguments = <DartType>[];
       for (int i = 0; i < numTypeArguments; i++) {
         typeArguments.add(getTypeArgument(i));
       }
     }
     return typeArguments;
   }
 }