Convert buildParameter() into a factory constructor.

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 2082 matching lines @@
       UnlinkedExecutable serializedExecutable) {
     executableElement.typeParameters =
         buildTypeParameters(serializedExecutable.typeParameters);
     {
       List<UnlinkedParam> unlinkedParameters = serializedExecutable.parameters;
       int length = unlinkedParameters.length;
       if (length != 0) {
         List<ParameterElementImpl> parameters =
             new List<ParameterElementImpl>(length);
         for (int i = 0; i < length; i++) {
-          parameters[i] =
-              buildParameter(unlinkedParameters[i], executableElement);
+          parameters[i] = new ParameterElementImpl.forSerializedFactory(
+              unlinkedParameters[i], executableElement);
         }
         executableElement.parameters = parameters;
       }
     }
     {
       List<UnlinkedExecutable> unlinkedFunctions =
           serializedExecutable.localFunctions;
       int length = unlinkedFunctions.length;
       if (length != 0) {
         List<FunctionElementImpl> localFunctions =
@@ skipping 116 matching lines @@
    * Resynthesize a [LabelElement].
    */
   LabelElement buildLocalLabel(UnlinkedLabel serializedLabel) {
     return new LabelElementImpl(
         serializedLabel.name,
         serializedLabel.nameOffset,
         serializedLabel.isOnSwitchStatement,
         serializedLabel.isOnSwitchMember);
   }
 
-  /**
-   * 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);
-      } else {
-        parameterElement =
-            new DefaultFieldFormalParameterElementImpl.forSerialized(
-                serializedParameter, enclosingElement);
-      }
-    } else {
-      if (serializedParameter.kind == UnlinkedParamKind.required) {
-        parameterElement = new ParameterElementImpl.forSerialized(
-            serializedParameter, enclosingElement);
-      } else {
-        parameterElement = new DefaultParameterElementImpl.forSerialized(
-            serializedParameter, enclosingElement);
-      }
-    }
-    parameterElement.synthetic = synthetic;
-    if (serializedParameter.isFunctionTyped) {
-      FunctionElementImpl parameterTypeElement =
-          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.returnType =
-          buildType(serializedParameter.type, _currentTypeParameterizedElement);
-      parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
-          parameterTypeElement, null, getCurrentTypeArguments(), false);
-      parameterTypeElement.type = parameterElement.type;
-    }
-    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);
         buildExecutableCommonParts(function, unlinkedExecutable);
         functions.add(function);
       }
@@ skipping 17 matching lines @@
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       FunctionElementImpl element =
           new FunctionElementImpl_forLUB(unit, typeParameterContext);
       element.parameters = type.syntheticParams
           .map((UnlinkedParam param) =>
-              buildParameter(param, element, synthetic: true))
+              new ParameterElementImpl.forSerializedFactory(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;
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
@@ skipping 14 matching lines @@
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     FunctionTypeAliasElementImpl functionTypeAliasElement =
         new FunctionTypeAliasElementImpl.forSerialized(serializedTypedef, unit);
     // TODO(scheglov) remove this after delaying parameters and their types
     currentTypeParameters.add(functionTypeAliasElement.typeParameters);
     functionTypeAliasElement.parameters = serializedTypedef.parameters
-        .map((p) => buildParameter(p, functionTypeAliasElement))
+        .map((p) => new ParameterElementImpl.forSerializedFactory(
+            p, functionTypeAliasElement))
         .toList();
     unitHolder.addTypeAlias(functionTypeAliasElement);
     // TODO(scheglov) remove this after delaying parameters and their types
     currentTypeParameters.removeLast();
     assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
    * its bound.
@@ skipping 422 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }