Resynthesize local variables lazily.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1597 matching lines @@
    * Initialize a newly created local variable element to have the given [name].
    */
   ConstLocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ConstLocalVariableElementImpl.forSerialized(UnlinkedVariable unlinkedVariable,
       ExecutableElementImpl enclosingExecutable)
       : super.forSerialized(unlinkedVariable, enclosingExecutable);
+
+  @override
+  Expression get constantInitializer {
+    if (_unlinkedVariable != null) {
+      UnlinkedConst defaultValue = _unlinkedVariable.initializer?.bodyExpr;
+      if (defaultValue == null) {
+        return null;
+      }
+      return super.constantInitializer ??= enclosingUnit.resynthesizerContext
+          .buildExpression(this, defaultValue);
+    }
+    return super.constantInitializer;
+  }
+
+  @override
+  void set constantInitializer(Expression initializer) {
+    assert(_unlinkedVariable == null);
+    super.constantInitializer = initializer;
+  }
 }
 
 /**
  * A concrete implementation of a [ConstructorElement].
  */
 class ConstructorElementImpl extends ExecutableElementImpl
     implements ConstructorElement {
   /**
    * The constructor to which this constructor is redirecting.
    */
@@ skipping 1207 matching lines @@
 
   /**
    * A list containing all of the labels defined within this executable element.
    */
   List<LabelElement> _labels = LabelElement.EMPTY_LIST;
 
   /**
    * A list containing all of the local variables defined within this executable
    * element.
    */
-  List<LocalVariableElement> _localVariables = LocalVariableElement.EMPTY_LIST;
+  List<LocalVariableElement> _localVariables;
 
   /**
    * A list containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters;
 
   /**
    * A list containing all of the type parameters defined for this executable
    * element.
    */
@@ skipping 176 matching lines @@
    * [labels].
    */
   void set labels(List<LabelElement> labels) {
     for (LabelElement label in labels) {
       (label as LabelElementImpl).enclosingElement = this;
     }
     this._labels = labels;
   }
 
   @override
-  List<LocalVariableElement> get localVariables => _localVariables;
+  List<LocalVariableElement> get localVariables {
+    if (serializedExecutable != null && _localVariables == null) {
+      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] = new LocalVariableElementImpl.forSerializedFactory(
+              unlinkedVariables[i], this);
+        }
+        _localVariables = localVariables;
+      } else {
+        _localVariables = const <LocalVariableElement>[];
+      }
+    }
+    return _localVariables ?? const <LocalVariableElement>[];
+  }
 
   /**
    * Set the local variables defined within this executable element to the given
    * [variables].
    */
   void set localVariables(List<LocalVariableElement> variables) {
+    assert(serializedExecutable == null);
     for (LocalVariableElement variable in variables) {
       (variable as LocalVariableElementImpl).enclosingElement = this;
     }
     this._localVariables = variables;
   }
 
   @override
   List<ElementAnnotation> get metadata {
     if (serializedExecutable != null) {
       return _metadata ??=
@@ skipping 2121 matching lines @@
    */
   LocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   LocalVariableElementImpl.forSerialized(UnlinkedVariable unlinkedVariable,
       ExecutableElementImpl enclosingExecutable)
       : super.forSerialized(unlinkedVariable, enclosingExecutable);
 
+  /**
+   * Initialize using the given serialized information.
+   */
+  factory LocalVariableElementImpl.forSerializedFactory(
+      UnlinkedVariable unlinkedVariable,
+      ExecutableElementImpl enclosingExecutable) {
+    if (unlinkedVariable.isConst &&
+        unlinkedVariable.initializer?.bodyExpr != null) {
+      return new ConstLocalVariableElementImpl.forSerialized(
+          unlinkedVariable, enclosingExecutable);
+    } else {
+      return new LocalVariableElementImpl.forSerialized(
+          unlinkedVariable, enclosingExecutable);
+    }
+  }
+
   @override
   String get identifier {
     int enclosingOffset =
         enclosingElement != null ? enclosingElement.nameOffset : 0;
     int delta = nameOffset - enclosingOffset;
     return '${super.identifier}@$delta';
   }
 
   @override
   bool get isPotentiallyMutatedInClosure => true;
 
   @override
   bool get isPotentiallyMutatedInScope => true;
 
   @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   @override
   SourceRange get visibleRange {
+    if (_unlinkedVariable != null) {
+      if (_unlinkedVariable.visibleLength == 0) {
+        return null;
+      }
+      return new SourceRange(
+          _unlinkedVariable.visibleOffset, _unlinkedVariable.visibleLength);
+    }
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
   @override
   Declaration computeNode() => getNodeMatching(
       (node) => node is DeclaredIdentifier || node is VariableDeclaration);
 
   /**
    * Set the visible range for this element to the range starting at the given
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
+    assert(_unlinkedVariable == null);
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 }
 
 /**
  * A concrete implementation of a [MethodElement].
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
@@ skipping 581 matching lines @@
     return super.hasImplicitType;
   }
 
   @override
   void set hasImplicitType(bool hasImplicitType) {
     assert(_unlinkedVariable == null);
     super.hasImplicitType = hasImplicitType;
   }
 
   @override
+  FunctionElement get initializer {
+    if (_unlinkedVariable != null && _initializer == null) {
+      _initializer = enclosingUnit.resynthesizerContext
+          .buildVariableInitializer(this, _unlinkedVariable.initializer);
+    }
+    return super.initializer;
+  }
+
+  /**
+   * Set the function representing this variable's initializer to the given
+   * [function].
+   */
+  void set initializer(FunctionElement function) {
+    assert(_unlinkedVariable == null);
+    super.initializer = function;
+  }
+
+  @override
   bool get isConst {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.isConst;
     }
     return super.isConst;
   }
 
   @override
   bool get isFinal {
     if (_unlinkedVariable != null) {
@@ skipping 179 matching lines @@
     return super.hasImplicitType;
   }
 
   @override
   void set hasImplicitType(bool hasImplicitType) {
     assert(_unlinkedParam == null);
     super.hasImplicitType = hasImplicitType;
   }
 
   @override
+  FunctionElement get initializer {
+    if (_unlinkedParam != null && _initializer == null) {
+      _initializer = enclosingUnit.resynthesizerContext
+          .buildVariableInitializer(this, _unlinkedParam.initializer);
+    }
+    return super.initializer;
+  }
+
+  /**
+   * Set the function representing this variable's initializer to the given
+   * [function].
+   */
+  void set initializer(FunctionElement function) {
+    assert(_unlinkedParam == null);
+    super.initializer = function;
+  }
+
+  @override
   bool get isConst {
     if (_unlinkedParam != null) {
       return false;
     }
     return super.isConst;
   }
 
   @override
   bool get isFinal {
     if (_unlinkedParam != null) {
@@ skipping 651 matching lines @@
    * Build top-level functions.
    */
   List<FunctionElementImpl> buildTopLevelFunctions();
 
   /**
    * Build explicit top-level variables.
    */
   UnitExplicitTopLevelVariables buildTopLevelVariables();
 
   /**
+   * If the given [serializedInitializer] is not `null`, create the
+   * corresponding [FunctionElementImpl] and set it for the [variable].
+   *
+   * TODO(scheglov) get rid of this when all parts are lazy
+   */
+  FunctionElementImpl buildVariableInitializer(
+      VariableElementImpl variable, UnlinkedExecutable serializedInitializer);
+
+  /**
    * Build the appropriate [DartType] object corresponding to a slot id in the
    * [LinkedUnit.types] table.
    */
   DartType resolveLinkedType(
       int slot, TypeParameterizedElementMixin typeParameterContext);
 
   /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
@@ skipping 651 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }