Resynthesize FieldFormalParameterElementImpl(s) 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 1780 matching lines @@
    * [nameOffset].
    */
   DefaultFieldFormalParameterElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
 
   /**
    * Initialize a newly created parameter element to have the given [name].
    */
   DefaultFieldFormalParameterElementImpl.forNode(Identifier name)
       : super.forNode(name);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  DefaultFieldFormalParameterElementImpl.forSerialized(
+      UnlinkedParam unlinkedParam, ElementImpl enclosingElement)
+      : super.forSerialized(unlinkedParam, enclosingElement);
+
+  @override
+  Expression get constantInitializer {
+    if (_unlinkedParam != null) {
+      UnlinkedConst defaultValue = _unlinkedParam.defaultValue;
+      if (defaultValue == null) {
+        return null;
+      }
+      return super.constantInitializer ??= enclosingUnit.resynthesizerContext
+          .buildExpression(this, defaultValue);
+    }
+    return super.constantInitializer;
+  }
+
+  @override
+  void set constantInitializer(Expression initializer) {
+    assert(_unlinkedParam == null);
+    super.constantInitializer = initializer;
+  }
 }
 
 /**
  * A [ParameterElement] for parameters that have an initializer.
  */
 class DefaultParameterElementImpl extends ParameterElementImpl
     with ConstVariableElement {
   /**
    * Initialize a newly created parameter element to have the given [name] and
    * [nameOffset].
@@ skipping 1520 matching lines @@
 
 /**
  * A [ParameterElementImpl] that has the additional information of the
  * [FieldElement] associated with the parameter.
  */
 class FieldFormalParameterElementImpl extends ParameterElementImpl
     implements FieldFormalParameterElement {
   /**
    * The field associated with this field formal parameter.
    */
-  FieldElement field;
+  FieldElement _field;
 
   /**
    * Initialize a newly created parameter element to have the given [name] and
    * [nameOffset].
    */
   FieldFormalParameterElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
 
   /**
    * Initialize a newly created parameter element to have the given [name].
    */
   FieldFormalParameterElementImpl.forNode(Identifier name)
       : super.forNode(name);
 
+  /**
+   * Initialize using the given serialized information.
+   */
+  FieldFormalParameterElementImpl.forSerialized(
+      UnlinkedParam unlinkedParam, ElementImpl enclosingElement)
+      : super.forSerialized(unlinkedParam, enclosingElement);
+
+  @override
+  FieldElement get field {
+    if (_unlinkedParam != null && _field == null) {
+      Element enclosingClass = enclosingElement?.enclosingElement;
+      if (enclosingClass is ClassElement) {
+        _field = enclosingClass.getField(_unlinkedParam.name);
+      }
+    }
+    return _field;
+  }
+
+  void set field(FieldElement field) {
+    assert(_unlinkedParam == null);
+    _field = field;
+  }
+
   @override
   bool get isInitializingFormal => true;
 
   @override
+  DartType get type {
+    if (_unlinkedParam != null && _unlinkedParam.type == null) {
+      _type ??= field?.type ?? DynamicTypeImpl.instance;
+    }
+    return super.type;
+  }
+
+  @override
+  void set type(DartType type) {
+    assert(_unlinkedParam == null);
+    _type = type;
+  }
+
+  @override
   accept(ElementVisitor visitor) =>
       visitor.visitFieldFormalParameterElement(this);
 }
 
 /**
  * Indicates that an ElementImpl's hashCode cannot currently be changed.
  */
 class FrozenHashCodeException implements Exception {
   final String _message;
 
@@ skipping 129 matching lines @@
    * [parameters] without becoming the parent of the parameters. This should
    * only be used by the [TypeResolverVisitor] when creating a synthetic type
    * alias.
    */
   void shareTypeParameters(List<TypeParameterElement> typeParameters) {
     this._typeParameters = typeParameters;
   }
 }
 
 /**
+ * Implementation of [FunctionElementImpl] for a function typed parameter.
+ */
+class FunctionElementImpl_forFunctionTypedParameter
+    extends FunctionElementImpl {
+  @override
+  final CompilationUnitElementImpl enclosingUnit;
+
+  /**
+   * The enclosing function typed [ParameterElementImpl].
+   */
+  final ParameterElementImpl _parameter;
+
+  FunctionElementImpl_forFunctionTypedParameter(
+      this.enclosingUnit, this._parameter)
+      : super('', -1);
+
+  @override
+  TypeParameterizedElementMixin get enclosingTypeParameterContext =>
+      _parameter.typeParameterContext;
+
+  @override
+  bool get isSynthetic => true;
+}
+
+/**
+ * Implementation of [FunctionElementImpl] for a synthetic function element
+ * that was synthesized by a LUB computation.
+ */
+class FunctionElementImpl_forLUB extends FunctionElementImpl {
+  @override
+  final CompilationUnitElementImpl enclosingUnit;
+
+  @override
+  final TypeParameterizedElementMixin enclosingTypeParameterContext;
+
+  FunctionElementImpl_forLUB(
+      this.enclosingUnit, this.enclosingTypeParameterContext)
+      : super('', -1);
+
+  @override
+  bool get isSynthetic => true;
+}
+
+/**
  * A concrete implementation of a [FunctionTypeAliasElement].
  */
 class FunctionTypeAliasElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements FunctionTypeAliasElement {
   /**
    * The unlinked representation of the type in the summary.
    */
   final UnlinkedTypedef _unlinkedTypedef;
 
@@ skipping 2329 matching lines @@
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
+  DartType get type {
+    if (_unlinkedParam != null && _type == null) {
+      _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
+              _unlinkedParam.inferredTypeSlot, typeParameterContext) ??
+          enclosingUnit.resynthesizerContext
+              .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
+    }
+    return super.type;
+  }
+
+  @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters defined by this parameter element to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     for (TypeParameterElement parameter in typeParameters) {
       (parameter as TypeParameterElementImpl).enclosingElement = this;
     }
@@ skipping 419 matching lines @@
    * Build top-level functions.
    */
   List<FunctionElementImpl> buildTopLevelFunctions();
 
   /**
    * Build explicit top-level variables.
    */
   UnitExplicitTopLevelVariables buildTopLevelVariables();
 
   /**
+   * 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].
    *
    * TODO(paulberry): or should we have a class representing an
    * unresolved type, for consistency with the full element model?
    */
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true});
 }
@@ skipping 463 matching lines @@
 }
 
 /**
  * A concrete implementation of a [VariableElement].
  */
 abstract class VariableElementImpl extends ElementImpl
     implements VariableElement {
   /**
    * The declared type of this variable.
    */
-  DartType type;
+  DartType _type;
 
   /**
    * A synthetic function representing this variable's initializer, or `null` if
    * this variable does not have an initializer.
    */
   FunctionElement _initializer;
 
   /**
    * Initialize a newly created variable element to have the given [name] and
    * [offset].
@@ skipping 98 matching lines @@
   @override
   bool get isPotentiallyMutatedInClosure => false;
 
   @override
   bool get isPotentiallyMutatedInScope => false;
 
   @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
+  DartType get type => _type;
+
+  void set type(DartType type) {
+    _type = type;
+  }
+
+  @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
@@ skipping 13 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }