Resynthesize parameters lazily.

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 3099 matching lines @@
   @override
   int get nameOffset {
     if (serializedExecutable != null) {
       return serializedExecutable.nameOffset;
     }
     return super.nameOffset;
   }
 
   @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>[];
   }
 
   /**
    * Set the parameters defined by this executable element to the given
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
+    assert(serializedExecutable == null);
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (serializedExecutable != null && _returnType == null) {
       bool isSetter =
@@ skipping 585 matching lines @@
  * Implementation of [FunctionElementImpl] for a synthetic function element
  * that was synthesized by a LUB computation.
  */
 class FunctionElementImpl_forLUB extends FunctionElementImpl {
   @override
   final CompilationUnitElementImpl enclosingUnit;
 
   @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);
+  }
 }
 
 /**
  * A concrete implementation of a [FunctionTypeAliasElement].
  */
 class FunctionTypeAliasElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements FunctionTypeAliasElement {
   /**
    * The unlinked representation of the type in the summary.
    */
   final UnlinkedTypedef _unlinkedTypedef;
 
   /**
    * 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.
    */
   DartType _returnType;
 
   /**
    * The type of function defined by this type alias.
    */
   FunctionType _type;
@@ skipping 100 matching lines @@
 
   @override
   int get nameOffset {
     if (_unlinkedTypedef != null) {
       return _unlinkedTypedef.nameOffset;
     }
     return super.nameOffset;
   }
 
   @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;
       }
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
@@ skipping 84 matching lines @@
       buffer.write(returnType);
     }
   }
 
   @override
   FunctionTypeAlias computeNode() =>
       getNodeMatching((node) => node is FunctionTypeAlias);
 
   @override
   ElementImpl getChild(String identifier) {
-    for (ParameterElement parameter in _parameters) {
+    for (ParameterElement parameter in parameters) {
       ParameterElementImpl parameterImpl = parameter;
       if (parameterImpl.identifier == identifier) {
         return parameterImpl;
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
       TypeParameterElementImpl typeParameterImpl = typeParameter;
       if (typeParameterImpl.identifier == identifier) {
         return typeParameterImpl;
       }
     }
     return null;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
-    safelyVisitChildren(_parameters, visitor);
+    safelyVisitChildren(parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 }
 
 /**
  * A concrete implementation of a [HideElementCombinator].
  */
 class HideElementCombinatorImpl implements HideElementCombinator {
   /**
    * The unlinked representation of the combinator in the summary.
@@ skipping 3528 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }