Create lazy (Const)FieldElementImpl.

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 2290 matching lines @@
       constElement.constantInitializer = _buildConstExpression(
           enclosingExecutable, serializedVariable.constExpr);
     } else {
       element = new LocalVariableElementImpl.forSerialized(
           serializedVariable, enclosingExecutable);
     }
     if (serializedVariable.visibleOffset != 0) {
       element.setVisibleRange(
           serializedVariable.visibleOffset, serializedVariable.visibleLength);
     }
-    buildVariableCommonParts(element, serializedVariable,
-        isLazilyResynthesized: true);
+    buildVariableCommonParts(element, serializedVariable);
     return element;
   }
 
   /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(
       UnlinkedParam serializedParameter, ElementImpl enclosingElement,
       {bool synthetic: false}) {
     ParameterElementImpl parameterElement;
@@ skipping 91 matching lines @@
             serializedParameter.visibleLength);
       }
     }
     return parameterElement;
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildPropertyIntroducingElementCommonParts(
-      PropertyInducingElementImpl element, UnlinkedVariable serializedVariable,
-      {bool isLazilyResynthesized: false}) {
-    buildVariableCommonParts(element, serializedVariable,
-        isLazilyResynthesized: isLazilyResynthesized);
+      PropertyInducingElementImpl element,
+      UnlinkedVariable serializedVariable) {
+    buildVariableCommonParts(element, serializedVariable);
     element.propagatedType = buildLinkedType(
         serializedVariable.propagatedTypeSlot,
         _currentTypeParameterizedElement);
   }
 
   List<FunctionElementImpl> buildTopLevelFunctions() {
     List<FunctionElementImpl> functions = <FunctionElementImpl>[];
     List<UnlinkedExecutable> executables = unlinkedUnit.executables;
     for (UnlinkedExecutable unlinkedExecutable in executables) {
       if (unlinkedExecutable.kind == UnlinkedExecutableKind.functionOrMethod) {
@@ skipping 179 matching lines @@
         ConstTopLevelVariableElementImpl constElement =
             new ConstTopLevelVariableElementImpl.forSerialized(
                 unlinkedVariable, unit);
         element = constElement;
         constElement.constantInitializer =
             _buildConstExpression(null, unlinkedVariable.constExpr);
       } else {
         element = new TopLevelVariableElementImpl.forSerialized(
             unlinkedVariable, unit);
       }
-      buildPropertyIntroducingElementCommonParts(element, unlinkedVariable,
-          isLazilyResynthesized: true);
+      buildPropertyIntroducingElementCommonParts(element, unlinkedVariable);
       variablesData.variables[i] = element;
       // implicit accessors
       String name = element.name;
       DartType type = element.type;
       variablesData.implicitAccessors
           .add(buildImplicitGetter(element, name, type));
       if (!(element.isConst || element.isFinal)) {
         variablesData.implicitAccessors
             .add(buildImplicitSetter(element, name, type));
       }
     }
     return variablesData;
   }
 
   /**
    * Resynthesize a [TopLevelVariableElement] or [FieldElement].
    */
   void buildVariable(
       ClassElementImpl enclosingClass, UnlinkedVariable serializedVariable,
       [ElementHolder holder]) {
     if (holder == null) {
       throw new UnimplementedError('Must be lazy');
     } else {
       FieldElementImpl element;
       if (serializedVariable.constExpr != null &&
           (serializedVariable.isConst ||
               serializedVariable.isFinal && !serializedVariable.isStatic)) {
-        ConstFieldElementImpl constElement = new ConstFieldElementImpl(
-            serializedVariable.name, serializedVariable.nameOffset);
+        ConstFieldElementImpl constElement =
+            new ConstFieldElementImpl.forSerialized(
+                serializedVariable, enclosingClass);
         element = constElement;
         constElement.constantInitializer =
             _buildConstExpression(enclosingClass, serializedVariable.constExpr);
       } else {
-        element = new FieldElementImpl(
-            serializedVariable.name, serializedVariable.nameOffset);
+        element = new FieldElementImpl.forSerialized(
+            serializedVariable, enclosingClass);
       }
       buildPropertyIntroducingElementCommonParts(element, serializedVariable);
       element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
       fields[element.name] = element;
     }
   }
 
   /**
    * Handle the parts that are common to variables.
    */
   void buildVariableCommonParts(
-      VariableElementImpl element, UnlinkedVariable serializedVariable,
-      {bool isLazilyResynthesized: false}) {
+      VariableElementImpl element, UnlinkedVariable serializedVariable) {
     element.type = buildLinkedType(serializedVariable.inferredTypeSlot,
             _currentTypeParameterizedElement) ??
         buildType(serializedVariable.type, _currentTypeParameterizedElement);
-    if (!isLazilyResynthesized) {
-      element.const3 = serializedVariable.isConst;
-      element.final2 = serializedVariable.isFinal;
-      element.hasImplicitType = serializedVariable.type == null;
-      buildDocumentation(element, serializedVariable.documentationComment);
-      buildAnnotations(element, serializedVariable.annotations);
-      buildCodeRange(element, serializedVariable.codeRange);
-    }
     buildVariableInitializer(element, serializedVariable.initializer);
   }
 
   /**
    * 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) {
@@ skipping 271 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }