Convert buildParameter() into a factory constructor.

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 6020 matching lines @@
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ParameterElementImpl.forSerialized(
       this._unlinkedParam, ElementImpl enclosingElement)
       : 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(
       String name, DartType type, ParameterKind kind) {
     ParameterElementImpl element = new ParameterElementImpl(name, -1);
     element.type = type;
     element.synthetic = true;
     element.parameterKind = kind;
     return element;
   }
@@ skipping 150 matching lines @@
     }
     return _parameterKind;
   }
 
   void set parameterKind(ParameterKind parameterKind) {
     assert(_unlinkedParam == null);
     _parameterKind = parameterKind;
   }
 
   @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
    * [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);
+      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;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters defined by this parameter element to the given
    * [typeParameters].
@@ skipping 1232 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }