Convert buildParameter() into a factory constructor.

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

Index: pkg/analyzer/lib/src/dart/element/element.dart
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 944c9b941d532670c6c88cdbab6b54e2b6e02940..cbdf65c06fce93481289d544bb671b286ef3648e 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -6038,6 +6038,34 @@ class ParameterElementImpl extends VariableElementImpl
       : super.forSerialized(enclosingElement);
 
   /**
+   * Initialize using the given serialized information.
+   */
+  factory ParameterElementImpl.forSerializedFactory(
+      UnlinkedParam unlinkedParameter, ElementImpl enclosingElement,
+      {bool synthetic: false}) {
+    ParameterElementImpl element;
+    if (unlinkedParameter.isInitializingFormal) {
+      if (unlinkedParameter.kind == UnlinkedParamKind.required) {
+        element = new FieldFormalParameterElementImpl.forSerialized(
+            unlinkedParameter, enclosingElement);
+      } else {
+        element = new DefaultFieldFormalParameterElementImpl.forSerialized(
+            unlinkedParameter, enclosingElement);
+      }
+    } else {
+      if (unlinkedParameter.kind == UnlinkedParamKind.required) {
+        element = new ParameterElementImpl.forSerialized(
+            unlinkedParameter, enclosingElement);
+      } else {
+        element = new DefaultParameterElementImpl.forSerialized(
+            unlinkedParameter, enclosingElement);
+      }
+    }
+    element.synthetic = synthetic;
+    return element;
+  }
+
+  /**
    * Creates a synthetic parameter with [name], [type] and [kind].
    */
   factory ParameterElementImpl.synthetic(
@@ -6208,7 +6236,12 @@ class ParameterElementImpl extends VariableElementImpl
   }
 
   @override
-  List<ParameterElement> get parameters => _parameters;
+  List<ParameterElement> get parameters {
+    if (_unlinkedParam != null) {
+      type; // _parameters is set during computing 'type'

[Paul Berry, 2016/05/27 21:51:20]

Even with the comment, this code looks very strange and I worry someone would be
tempted to delete it.  Consider extracting everything but the last line in
`type` to a method called "_setTypeAndParameters()", and call it from here
rather than calling the getter.

[scheglov, 2016/05/27 21:57:04]

Done.

+    }
+    return _parameters;
+  }
 
   /**
    * Set the parameters defined by this executable element to the given
@@ -6224,10 +6257,38 @@ class ParameterElementImpl extends VariableElementImpl
   @override
   DartType get type {
     if (_unlinkedParam != null && _type == null) {
-      _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
-              _unlinkedParam.inferredTypeSlot, typeParameterContext) ??
-          enclosingUnit.resynthesizerContext
-              .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
+      if (_unlinkedParam.isFunctionTyped) {
+        CompilationUnitElementImpl enclosingUnit = this.enclosingUnit;
+        FunctionElementImpl parameterTypeElement =
+            new FunctionElementImpl_forFunctionTypedParameter(
+                enclosingUnit, this);
+        if (!isSynthetic) {
+          parameterTypeElement.enclosingElement = this;
+        }
+        List<ParameterElement> subParameters = _unlinkedParam.parameters
+            .map((UnlinkedParam p) =>
+                new ParameterElementImpl.forSerializedFactory(p, this,
+                    synthetic: isSynthetic))
+            .toList(growable: false);
+        if (isSynthetic) {
+          parameterTypeElement.parameters = subParameters;
+        } else {
+          _parameters = subParameters;
+          parameterTypeElement.shareParameters(subParameters);
+        }
+        parameterTypeElement.returnType = enclosingUnit.resynthesizerContext
+            .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
+        FunctionTypeImpl parameterType =
+            new FunctionTypeImpl.elementWithNameAndArgs(parameterTypeElement,
+                null, typeParameterContext.allTypeParameterTypes, false);
+        parameterTypeElement.type = parameterType;
+        _type = parameterType;
+      } else {
+        _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
+                _unlinkedParam.inferredTypeSlot, typeParameterContext) ??
+            enclosingUnit.resynthesizerContext
+                .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
+      }
     }
     return super.type;
   }