Resynthesize FieldFormalParameterElementImpl(s) 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 1528 matching lines @@
   List<FunctionElementImpl> buildTopLevelFunctions() {
     return _unitResynthesizer.buildTopLevelFunctions();
   }
 
   @override
   UnitExplicitTopLevelVariables buildTopLevelVariables() {
     return _unitResynthesizer.buildUnitExplicitTopLevelVariables();
   }
 
   @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,
         defaultVoid: defaultVoid,
         instantiateToBoundsAllowed: instantiateToBoundsAllowed);
   }
 }
 
 /**
@@ skipping 542 matching lines @@
         executableElement.parameters = parameters;
       }
     }
     if (serializedExecutable.kind == UnlinkedExecutableKind.constructor) {
       // Caller handles setting the return type.
       assert(serializedExecutable.returnType == null);
     } else {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
       executableElement.returnType = buildLinkedType(
-              serializedExecutable.inferredReturnTypeSlot,
-              _currentTypeParameterizedElement) ??
-          buildType(
-              serializedExecutable.returnType, _currentTypeParameterizedElement,
+              serializedExecutable.inferredReturnTypeSlot, executableElement) ??
+          buildType(serializedExecutable.returnType, executableElement,
               defaultVoid: isSetter && summaryResynthesizer.strongMode);
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, getCurrentTypeArguments(skipLevels: 1), false);
     {
       List<UnlinkedExecutable> unlinkedFunctions =
           serializedExecutable.localFunctions;
       int length = unlinkedFunctions.length;
       if (length != 0) {
         List<FunctionElementImpl> localFunctions =
@@ skipping 187 matching lines @@
     return element;
   }
 
   /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(
       UnlinkedParam serializedParameter, ElementImpl enclosingElement,
       {bool synthetic: false}) {
     ParameterElementImpl parameterElement;
-    bool isLazilyResynthesized = false;
-    int nameOffset = synthetic ? -1 : serializedParameter.nameOffset;
     if (serializedParameter.isInitializingFormal) {
       FieldFormalParameterElementImpl initializingParameter;
       if (serializedParameter.kind == UnlinkedParamKind.required) {
-        initializingParameter = new FieldFormalParameterElementImpl(
-            serializedParameter.name, nameOffset);
+        initializingParameter =
+            new FieldFormalParameterElementImpl.forSerialized(
+                serializedParameter, enclosingElement);
       } else {
-        DefaultFieldFormalParameterElementImpl defaultParameter =
-            new DefaultFieldFormalParameterElementImpl(
-                serializedParameter.name, nameOffset);
-        initializingParameter = defaultParameter;
-        if (serializedParameter.defaultValue != null) {
-          defaultParameter.constantInitializer = _buildConstExpression(
-              enclosingElement, serializedParameter.defaultValue);
-          defaultParameter.defaultValueCode =
-              serializedParameter.defaultValueCode;
-        }
+        initializingParameter =
+            new DefaultFieldFormalParameterElementImpl.forSerialized(
+                serializedParameter, enclosingElement);
       }
       parameterElement = initializingParameter;
-      initializingParameter.field = fields[serializedParameter.name];
     } else {
       if (serializedParameter.kind == UnlinkedParamKind.required) {
         parameterElement = new ParameterElementImpl.forSerialized(
             serializedParameter, enclosingElement);
-        isLazilyResynthesized = true;
       } else {
-        DefaultParameterElementImpl defaultParameter =
-            new DefaultParameterElementImpl.forSerialized(
-                serializedParameter, enclosingElement);
-        isLazilyResynthesized = true;
-        parameterElement = defaultParameter;
+        parameterElement = new DefaultParameterElementImpl.forSerialized(
+            serializedParameter, enclosingElement);
       }
     }
     parameterElement.synthetic = synthetic;
-    if (!isLazilyResynthesized) {
-      buildAnnotations(parameterElement, serializedParameter.annotations);
-      buildCodeRange(parameterElement, serializedParameter.codeRange);
-    }
     if (serializedParameter.isFunctionTyped) {
       FunctionElementImpl parameterTypeElement =
-          new FunctionElementImpl('', -1);
-      parameterTypeElement.synthetic = true;
+          new FunctionElementImpl_forFunctionTypedParameter(
+              unit, parameterElement);
+      if (!synthetic) {
+        parameterTypeElement.enclosingElement = parameterElement;
+      }
       List<ParameterElement> subParameters = serializedParameter.parameters
           .map((UnlinkedParam p) =>
               buildParameter(p, parameterTypeElement, synthetic: synthetic))
           .toList();
       if (synthetic) {
         parameterTypeElement.parameters = subParameters;
       } else {
         parameterElement.parameters = subParameters;
         parameterTypeElement.shareParameters(subParameters);
-        parameterTypeElement.enclosingElement = parameterElement;
       }
       parameterTypeElement.returnType =
           buildType(serializedParameter.type, _currentTypeParameterizedElement);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, getCurrentTypeArguments(), false);
       parameterTypeElement.type = parameterElement.type;
-    } else {
-      if (serializedParameter.isInitializingFormal &&
-          serializedParameter.type == null) {
-        // The type is inherited from the matching field.
-        parameterElement.type =
-            fields[serializedParameter.name]?.type ?? DynamicTypeImpl.instance;
-      } else {
-        parameterElement.type = buildLinkedType(
-                serializedParameter.inferredTypeSlot,
-                _currentTypeParameterizedElement) ??
-            buildType(
-                serializedParameter.type, _currentTypeParameterizedElement);
-      }
-      if (!isLazilyResynthesized) {
-        parameterElement.hasImplicitType = serializedParameter.type == null;
-      }
     }
     buildVariableInitializer(parameterElement, serializedParameter.initializer);
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
         break;
       case UnlinkedParamKind.required:
         parameterElement.parameterKind = ParameterKind.REQUIRED;
         break;
     }
-    if (!isLazilyResynthesized) {
-      if (serializedParameter.visibleOffset != 0) {
-        parameterElement.setVisibleRange(serializedParameter.visibleOffset,
-            serializedParameter.visibleLength);
-      }
-    }
     return parameterElement;
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildPropertyIntroducingElementCommonParts(
       PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
     buildVariableCommonParts(element, serializedVariable);
@@ skipping 28 matching lines @@
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
-      FunctionElementImpl element = new FunctionElementImpl('', -1);
-      element.synthetic = true;
+      FunctionElementImpl element =
+          new FunctionElementImpl_forLUB(unit, typeParameterContext);
       element.parameters = type.syntheticParams
           .map((UnlinkedParam param) =>
               buildParameter(param, element, synthetic: true))
           .toList();
       element.returnType =
           buildType(type.syntheticReturnType, typeParameterContext);
       FunctionTypeImpl result = new FunctionTypeImpl.elementWithNameAndArgs(
           element, null, null, false);
       element.type = result;
       return result;
@@ skipping 191 matching lines @@
       fields[element.name] = element;
     }
   }
 
   /**
    * Handle the parts that are common to variables.
    */
   void buildVariableCommonParts(
       VariableElementImpl element, UnlinkedVariable serializedVariable) {
     element.type = buildLinkedType(serializedVariable.inferredTypeSlot,
-            _currentTypeParameterizedElement) ??
-        buildType(serializedVariable.type, _currentTypeParameterizedElement);
+            element.typeParameterContext) ??
+        buildType(serializedVariable.type, element.typeParameterContext);
     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;
   }
 }