Resynthesize parameters lazily.

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 2897282b2b001ec88064d678d5af4b77e3fb30ca..66710f4175afcde63465428f156d6c00ed99b5e1 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -3117,6 +3117,21 @@ abstract class ExecutableElementImpl extends ElementImpl
 
   @override
   List<ParameterElement> get parameters {
+    if (serializedExecutable != null && _parameters == null) {
+      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] = new ParameterElementImpl.forSerializedFactory(
+              unlinkedParameters[i], this);
+        }
+        _parameters = parameters;
+      } else {
+        _parameters = const <ParameterElement>[];
+      }
+    }
     return _parameters ?? const <ParameterElement>[];
   }
 
@@ -3125,6 +3140,7 @@ abstract class ExecutableElementImpl extends ElementImpl
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
+    assert(serializedExecutable == null);
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
@@ -3730,12 +3746,50 @@ class FunctionElementImpl_forLUB extends FunctionElementImpl {
   @override
   final TypeParameterizedElementMixin enclosingTypeParameterContext;
 
+  final EntityRef _entityRef;
+
   FunctionElementImpl_forLUB(
-      this.enclosingUnit, this.enclosingTypeParameterContext)
+      this.enclosingUnit, this.enclosingTypeParameterContext, this._entityRef)
       : super('', -1);
 
   @override
   bool get isSynthetic => true;
+
+  @override
+  List<ParameterElement> get parameters {
+    return _parameters ??= _entityRef.syntheticParams
+        .map((UnlinkedParam param) =>
+            new ParameterElementImpl.forSerializedFactory(param, this,
+                synthetic: true))
+        .toList(growable: false);
+  }
+
+  @override
+  void set parameters(List<ParameterElement> parameters) {
+    assert(false);
+  }
+
+  @override
+  DartType get returnType {
+    return _returnType ??= enclosingUnit.resynthesizerContext
+        .resolveTypeRef(_entityRef.syntheticReturnType, typeParameterContext);
+  }
+
+  @override
+  void set returnType(DartType returnType) {
+    assert(false);
+  }
+
+  @override
+  FunctionType get type {
+    return _type ??=
+        new FunctionTypeImpl.elementWithNameAndArgs(this, null, null, false);
+  }
+
+  @override
+  void set type(FunctionType type) {
+    assert(false);
+  }
 }
 
 /**
@@ -3752,7 +3806,7 @@ class FunctionTypeAliasElementImpl extends ElementImpl
   /**
    * A list containing all of the parameters defined by this type alias.
    */
-  List<ParameterElement> _parameters = ParameterElement.EMPTY_LIST;
+  List<ParameterElement> _parameters;
 
   /**
    * The return type defined by this type alias.
@@ -3873,12 +3927,30 @@ class FunctionTypeAliasElementImpl extends ElementImpl
   }
 
   @override
-  List<ParameterElement> get parameters => _parameters;
+  List<ParameterElement> get parameters {
+    if (_unlinkedTypedef != null && _parameters == null) {
+      List<UnlinkedParam> unlinkedParameters = _unlinkedTypedef.parameters;
+      int length = unlinkedParameters.length;
+      if (length != 0) {
+        List<ParameterElementImpl> parameters =
+            new List<ParameterElementImpl>(length);
+        for (int i = 0; i < length; i++) {
+          parameters[i] = new ParameterElementImpl.forSerializedFactory(
+              unlinkedParameters[i], this);
+        }
+        _parameters = parameters;
+      } else {
+        _parameters = const <ParameterElement>[];
+      }
+    }
+    return _parameters ?? const <ParameterElement>[];

[Brian Wilkerson, 2016/05/27 22:38:15]

Seems like I've seen a lot of code with this same pattern lately. It appears
twice in this CL alone. Would it be useful to define some utility methods
similar to

class UnlinkedParam {
  static List<ParameterElement> deserialize(List<UnlinkedParam>
unlinkedParameters) {
    int length = unlinkedParameters.length;
    ...
  }
}

[scheglov, 2016/05/28 02:00:35]

Good point.
Done.

+  }
 
   /**
    * Set the parameters defined by this type alias to the given [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
+    assert(_unlinkedTypedef == null);
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
@@ -3983,7 +4055,7 @@ class FunctionTypeAliasElementImpl extends ElementImpl
 
   @override
   ElementImpl getChild(String identifier) {
-    for (ParameterElement parameter in _parameters) {
+    for (ParameterElement parameter in parameters) {
       ParameterElementImpl parameterImpl = parameter;
       if (parameterImpl.identifier == identifier) {
         return parameterImpl;
@@ -4001,7 +4073,7 @@ class FunctionTypeAliasElementImpl extends ElementImpl
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
-    safelyVisitChildren(_parameters, visitor);
+    safelyVisitChildren(parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 }