Create ExecutableElementImpl.type 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 8c2085c9a3348c5edad40ccb1591dc65c1fc8a6a..746e88fb7d19d71e55b9371298dfc8a50f0d7df1 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -3114,9 +3114,16 @@ abstract class ExecutableElementImpl extends ElementImpl
   }
 
   @override
-  FunctionType get type => _type;
+  FunctionType get type {
+    if (serializedExecutable != null) {
+      _type ??= new FunctionTypeImpl.elementWithNameAndArgs(
+          this, null, allEnclosingTypeParameterTypes, false);
+    }
+    return _type;
+  }
 
   void set type(FunctionType type) {
+    assert(serializedExecutable == null);
     _type = type;
   }
 
@@ -5260,6 +5267,14 @@ class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   }
 
   @override
+  List<TypeParameterType> get allEnclosingTypeParameterTypes {
+    if (isStatic) {
+      return const <TypeParameterType>[];
+    }
+    return super.allEnclosingTypeParameterTypes;
+  }
+
+  @override
   String get displayName {
     String displayName = super.displayName;
     if ("unary-" == displayName) {
@@ -6374,6 +6389,14 @@ class PropertyAccessorElementImpl extends ExecutableElementImpl
   }
 
   @override
+  List<TypeParameterType> get allEnclosingTypeParameterTypes {
+    if (isStatic) {
+      return const <TypeParameterType>[];
+    }
+    return super.allEnclosingTypeParameterTypes;
+  }
+
+  @override
   PropertyAccessorElement get correspondingGetter {
     if (isGetter || variable == null) {
       return null;
@@ -6998,9 +7021,31 @@ class TypeParameterElementImpl extends ElementImpl
  */
 abstract class TypeParameterizedElementMixin
     implements TypeParameterizedElement, ElementImpl {
-  List<TypeParameterType> _typeParameterTypes;
-  List<TypeParameterElement> _typeParameterElements;
   int _nestingLevel;
+  List<TypeParameterElement> _typeParameterElements;
+  List<TypeParameterType> _typeParameterTypes;
+  List<TypeParameterType> _allTypeParameterTypes;
+
+  /**
+   * Return all type parameter types of the element that encloses element.
+   * Not `null`, but might be empty for top-level and static class members.
+   */
+  List<TypeParameterType> get allEnclosingTypeParameterTypes {
+    return enclosingTypeParameterContext?.allTypeParameterTypes ??
+        const <TypeParameterType>[];
+  }
+
+  /**
+   * Return all type parameter types of this element.
+   */
+  List<TypeParameterType> get allTypeParameterTypes {
+    if (_allTypeParameterTypes == null) {
+      _allTypeParameterTypes = <TypeParameterType>[];
+      _allTypeParameterTypes.addAll(typeParameterTypes);
+      _allTypeParameterTypes.addAll(allEnclosingTypeParameterTypes);

[Paul Berry, 2016/05/27 17:04:50]

This order seems backwards.  Shouldn't we list outermost type parameters first?

+    }
+    return _allTypeParameterTypes;
+  }
 
   /**
    * Get the type parameter context enclosing this one, if any.