Resynthesize local variables lazily.

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 1527 matching lines @@
   List<FunctionElementImpl> buildTopLevelFunctions() {
     return _unitResynthesizer.buildTopLevelFunctions();
   }
 
   @override
   UnitExplicitTopLevelVariables buildTopLevelVariables() {
     return _unitResynthesizer.buildUnitExplicitTopLevelVariables();
   }
 
   @override
+  FunctionElementImpl buildVariableInitializer(
+      VariableElementImpl variable, UnlinkedExecutable serializedInitializer) {
+    return _unitResynthesizer.buildVariableInitializer(
+        variable, serializedInitializer);
+  }
+
+  @override
   DartType resolveLinkedType(
       int slot, TypeParameterizedElementMixin typeParameterContext) {
     return _unitResynthesizer.buildLinkedType(slot, typeParameterContext);
   }
 
   @override
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
     return _unitResynthesizer.buildType(type, typeParameterContext,
@@ skipping 559 matching lines @@
       List<UnlinkedLabel> unlinkedLabels = serializedExecutable.localLabels;
       int length = unlinkedLabels.length;
       if (length != 0) {
         List<LabelElementImpl> localLabels = new List<LabelElementImpl>(length);
         for (int i = 0; i < length; i++) {
           localLabels[i] = buildLocalLabel(unlinkedLabels[i]);
         }
         executableElement.labels = localLabels;
       }
     }
-    {
-      List<UnlinkedVariable> unlinkedVariables =
-          serializedExecutable.localVariables;
-      int length = unlinkedVariables.length;
-      if (length != 0) {
-        List<LocalVariableElementImpl> localVariables =
-            new List<LocalVariableElementImpl>(length);
-        for (int i = 0; i < length; i++) {
-          localVariables[i] =
-              buildLocalVariable(unlinkedVariables[i], executableElement);
-        }
-        executableElement.localVariables = localVariables;
-      }
-    }
     currentTypeParameters.removeLast();
   }
 
   /**
    * Build the implicit getter and setter associated with [element], and place
    * them in [holder].
    */
   void buildImplicitAccessors(
       PropertyInducingElementImpl element, ElementHolder holder) {
     PropertyAccessorElementImpl getter = buildImplicitGetter(element);
@@ skipping 88 matching lines @@
    */
   LabelElement buildLocalLabel(UnlinkedLabel serializedLabel) {
     return new LabelElementImpl(
         serializedLabel.name,
         serializedLabel.nameOffset,
         serializedLabel.isOnSwitchStatement,
         serializedLabel.isOnSwitchMember);
   }
 
   /**
-   * Resynthesize a [LocalVariableElement].
-   */
-  LocalVariableElement buildLocalVariable(UnlinkedVariable serializedVariable,
-      ExecutableElementImpl enclosingExecutable) {
-    LocalVariableElementImpl element;
-    if (serializedVariable.initializer?.bodyExpr != null &&
-        serializedVariable.isConst) {
-      ConstLocalVariableElementImpl constElement =
-          new ConstLocalVariableElementImpl.forSerialized(
-              serializedVariable, enclosingExecutable);
-      element = constElement;
-      constElement.constantInitializer = _buildConstExpression(
-          enclosingExecutable, serializedVariable.initializer.bodyExpr);
-    } else {
-      element = new LocalVariableElementImpl.forSerialized(
-          serializedVariable, enclosingExecutable);
-    }
-    if (serializedVariable.visibleOffset != 0) {
-      element.setVisibleRange(
-          serializedVariable.visibleOffset, serializedVariable.visibleLength);
-    }
-    buildVariableCommonParts(element, serializedVariable);
-    return element;
-  }
-
-  /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(
       UnlinkedParam serializedParameter, ElementImpl enclosingElement,
       {bool synthetic: false}) {
     ParameterElementImpl parameterElement;
     if (serializedParameter.isInitializingFormal) {
       if (serializedParameter.kind == UnlinkedParamKind.required) {
         parameterElement = new FieldFormalParameterElementImpl.forSerialized(
             serializedParameter, enclosingElement);
@@ skipping 28 matching lines @@
       } else {
         parameterElement.parameters = subParameters;
         parameterTypeElement.shareParameters(subParameters);
       }
       parameterTypeElement.returnType =
           buildType(serializedParameter.type, _currentTypeParameterizedElement);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, getCurrentTypeArguments(), false);
       parameterTypeElement.type = parameterElement.type;
     }
-    buildVariableInitializer(parameterElement, serializedParameter.initializer);
     return parameterElement;
   }
 
   List<FunctionElementImpl> buildTopLevelFunctions() {
     List<FunctionElementImpl> functions = <FunctionElementImpl>[];
     List<UnlinkedExecutable> executables = unlinkedUnit.executables;
     for (UnlinkedExecutable unlinkedExecutable in executables) {
       if (unlinkedExecutable.kind == UnlinkedExecutableKind.functionOrMethod) {
         FunctionElementImpl function =
             new FunctionElementImpl.forSerialized(unlinkedExecutable, unit);
@@ skipping 174 matching lines @@
         ConstTopLevelVariableElementImpl constElement =
             new ConstTopLevelVariableElementImpl.forSerialized(
                 unlinkedVariable, unit);
         element = constElement;
         constElement.constantInitializer =
             _buildConstExpression(null, unlinkedVariable.initializer.bodyExpr);
       } else {
         element = new TopLevelVariableElementImpl.forSerialized(
             unlinkedVariable, unit);
       }
-      buildVariableCommonParts(element, unlinkedVariable);
       variablesData.variables[i] = element;
       // implicit accessors
       variablesData.implicitAccessors.add(buildImplicitGetter(element));
       if (!(element.isConst || element.isFinal)) {
         variablesData.implicitAccessors.add(buildImplicitSetter(element));
       }
     }
     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.initializer?.bodyExpr != null &&
           (serializedVariable.isConst ||
               serializedVariable.isFinal && !serializedVariable.isStatic)) {
         element = new ConstFieldElementImpl.forSerialized(
             serializedVariable, enclosingClass);
       } else {
         element = new FieldElementImpl.forSerialized(
             serializedVariable, enclosingClass);
       }
-      buildVariableCommonParts(element, serializedVariable);
       element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
       fields[element.name] = element;
     }
   }
 
   /**
-   * Handle the parts that are common to variables.
+   * If the given [serializedInitializer] is not `null`, return the
+   * corresponding [FunctionElementImpl], otherwise return `null`.
    */
-  void buildVariableCommonParts(
-      VariableElementImpl element, UnlinkedVariable serializedVariable) {
-    buildVariableInitializer(element, serializedVariable.initializer);
-  }
-
-  /**
-   * If the given [serializedInitializer] is not `null`, create the
-   * corresponding [FunctionElementImpl] and set it for the [variable].
-   */
-  void buildVariableInitializer(
+  FunctionElementImpl buildVariableInitializer(
       VariableElementImpl variable, UnlinkedExecutable serializedInitializer) {
     if (serializedInitializer == null) {
       return null;
     }
     FunctionElementImpl initializerElement =
         buildLocalFunction(serializedInitializer, variable);
     initializerElement.synthetic = true;
-    variable.initializer = initializerElement;
+    return initializerElement;
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(
           serializedTypeParameter.bound, _currentTypeParameterizedElement,
@@ skipping 255 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }