Implement FunctionElementForLink_FunctionTypedParam.parameters.

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 172 matching lines @@
     return result;
   } else if (type is TypeParameterType) {
     TypeParameterElementForLink element = type.element;
     result.paramReference =
         typeParameterContext.typeParameterNestingLevel - element.nestingLevel;
     return result;
   } else if (type is FunctionType) {
     Element element = type.element;
     if (element is FunctionElementForLink_FunctionTypedParam) {
       result.reference =
-          compilationUnit.addReference(element.enclosingExecutable);
+          compilationUnit.addReference(element.innermostExecutable);
       result.implicitFunctionTypeIndices = element.implicitFunctionTypeIndices;
       if (type.typeArguments.isNotEmpty) {
         result.typeArguments = type.typeArguments
             .map((DartType t) =>
                 _createLinkedType(t, compilationUnit, typeParameterContext))
             .toList();
       }
       return result;
     }
     if (element is TopLevelFunctionElementForLink) {
@@ skipping 1375 matching lines @@
     // Kick off the algorithm starting with the starting point.
     strongConnect(startingPoint);
   }
 }
 
 /**
  * Base class for executable elements resynthesized from a summary during
  * linking.
  */
 abstract class ExecutableElementForLink extends Object
-    with TypeParameterizedElementForLink
+    with TypeParameterizedElementForLink, ParameterParentElementForLink
     implements ExecutableElementImpl {
   /**
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   List<TypeParameterElementForLink> _typeParameters;
   String _name;
-  List<ParameterElementForLink> _parameters;
   String _displayName;
 
   /**
    * Return the class in which this executable appears, maybe `null` for a
    * top-level function.
    */
   final ClassElementForLink_Class enclosingClass;
 
   /**
    * Return the compilation unit in which this executable appears.
@@ skipping 30 matching lines @@
   @override
   Element get enclosingElement => enclosingClass ?? enclosingUnit;
 
   @override
   TypeParameterizedElementForLink get enclosingTypeParameterContext =>
       enclosingClass;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
+  @override
+  List<int> get implicitFunctionTypeIndices => const <int>[];
+
   /**
    * Return the inferred return type of the executable element.  Should only be
    * called if no return type was explicitly declared.
    */
   DartType get inferredReturnType {
     // We should only try to infer a return type when none is explicitly
     // declared.
     assert(_unlinkedExecutable.returnType == null);
     if (Linker._initializerTypeInferenceCycle != null &&
         Linker._initializerTypeInferenceCycle ==
@@ skipping 10 matching lines @@
         _inferredReturnType = _computeDefaultReturnType();
       } else {
         _inferredReturnType = enclosingUnit.getLinkedType(
             _unlinkedExecutable.inferredReturnTypeSlot, this);
       }
     }
     return _inferredReturnType;
   }
 
   @override
+  ExecutableElementForLink get innermostExecutable => this;
+
+  @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   String get name {
     if (_name == null) {
       _name = _unlinkedExecutable.name;
       if (_name == '-' && _unlinkedExecutable.parameters.isEmpty) {
         _name = 'unary-';
       }
     }
     return _name;
   }
 
   @override
-  List<ParameterElementForLink> get parameters {
-    if (_parameters == null) {
-      int numParameters = _unlinkedExecutable.parameters.length;
-      _parameters = new List<ParameterElementForLink>(numParameters);
-      for (int i = 0; i < numParameters; i++) {
-        UnlinkedParam unlinkedParam = _unlinkedExecutable.parameters[i];
-        _parameters[i] = new ParameterElementForLink(
-            this, unlinkedParam, this, enclosingUnit, i);
-      }
-    }
-    return _parameters;
-  }
-
-  @override
   DartType get returnType => declaredReturnType ?? inferredReturnType;
 
   @override
   void set returnType(DartType inferredType) {
     assert(_inferredReturnType == null);
     _inferredReturnType = inferredType;
   }
 
   @override
   FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
 
   @override
+  List<UnlinkedParam> get unlinkedParameters => _unlinkedExecutable.parameters;
+
+  @override
   List<UnlinkedTypeParam> get _unlinkedTypeParams =>
       _unlinkedExecutable.typeParameters;
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   /**
    * Store the results of type inference for this method in [compilationUnit].
    */
@@ skipping 771 matching lines @@
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Element representing a function-typed parameter resynthesied from a summary
  * during linking.
  */
-class FunctionElementForLink_FunctionTypedParam implements FunctionElement {
+class FunctionElementForLink_FunctionTypedParam extends Object
+    with ParameterParentElementForLink
+    implements FunctionElement {
   @override
   final ParameterElementForLink enclosingElement;
 
-  /**
-   * The executable element containing this function-typed parameter.
-   */
-  final Element enclosingExecutable;
+  @override
+  final ExecutableElementForLink innermostExecutable;
 
-  /**
-   * The appropriate integer list to store in
-   * [EntityRef.implicitFunctionTypeIndices] to refer to this function-typed
-   * parameter.
-   */
-  final List<int> implicitFunctionTypeIndices;
+  @override
+  final List<UnlinkedParam> unlinkedParameters;
 
   DartType _returnType;
+  List<int> _implicitFunctionTypeIndices;
 
-  FunctionElementForLink_FunctionTypedParam(this.enclosingElement,
-      this.enclosingExecutable, this.implicitFunctionTypeIndices);
+  FunctionElementForLink_FunctionTypedParam(
+      this.enclosingElement, this.innermostExecutable, this.unlinkedParameters);
+
+  @override
+  List<int> get implicitFunctionTypeIndices {
+    if (_implicitFunctionTypeIndices == null) {
+      _implicitFunctionTypeIndices = enclosingElement
+          .enclosingElement.implicitFunctionTypeIndices
+          .toList();
+      _implicitFunctionTypeIndices.add(enclosingElement._parameterIndex);
+    }
+    return _implicitFunctionTypeIndices;
+  }
 
   @override
   DartType get returnType {
     if (_returnType == null) {
       if (enclosingElement._unlinkedParam.type == null) {
         _returnType = DynamicTypeImpl.instance;
       } else {
         _returnType = enclosingElement.compilationUnit._resolveTypeRef(
-            enclosingElement._unlinkedParam.type,
-            enclosingElement._typeParameterContext);
+            enclosingElement._unlinkedParam.type, innermostExecutable);
       }
     }
     return _returnType;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
@@ skipping 705 matching lines @@
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
  */
 class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
    */
   final UnlinkedParam _unlinkedParam;
 
   /**
-   * The context in which type parameters should be interpreted.
+   * The innermost executable element containing this parameter.
    */
-  final TypeParameterizedElementForLink _typeParameterContext;
+  final ExecutableElementForLink _innermostExecutable;
 
   /**
    * If this parameter has a default value and the enclosing library
    * is part of the build unit being linked, the parameter's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstNode _constNode;
 
   /**
    * The compilation unit in which this parameter appears.
    */
   final CompilationUnitElementForLink compilationUnit;
 
   /**
    * The index of this parameter within [enclosingElement]'s parameter list.
    */
   final int _parameterIndex;
 
   @override
-  final ExecutableElementForLink enclosingElement;
+  final ParameterParentElementForLink enclosingElement;
 
   DartType _inferredType;
   DartType _declaredType;
 
   ParameterElementForLink(this.enclosingElement, this._unlinkedParam,
-      this._typeParameterContext, this.compilationUnit, this._parameterIndex) {
+      this._innermostExecutable, this.compilationUnit, this._parameterIndex) {
     if (_unlinkedParam.defaultValue != null) {
       _constNode = new ConstParameterNode(this);
     }
   }
 
   @override
   bool get hasImplicitType =>
       !_unlinkedParam.isFunctionTyped && _unlinkedParam.type == null;
 
   @override
@@ skipping 12 matching lines @@
   }
 
   @override
   DartType get type {
     if (_inferredType != null) {
       return _inferredType;
     } else if (_declaredType == null) {
       if (_unlinkedParam.isFunctionTyped) {
         _declaredType = new FunctionTypeImpl(
             new FunctionElementForLink_FunctionTypedParam(
-                this, enclosingElement, <int>[_parameterIndex]));
+                this, _innermostExecutable, _unlinkedParam.parameters));
       } else if (_unlinkedParam.type == null) {
         if (!compilationUnit.isInBuildUnit) {
           _inferredType = compilationUnit.getLinkedType(
-              _unlinkedParam.inferredTypeSlot, _typeParameterContext);
+              _unlinkedParam.inferredTypeSlot, _innermostExecutable);
           return _inferredType;
         } else {
           _declaredType = DynamicTypeImpl.instance;
         }
       } else {
         _declaredType = compilationUnit._resolveTypeRef(
-            _unlinkedParam.type, _typeParameterContext);
+            _unlinkedParam.type, _innermostExecutable);
       }
     }
     return _declaredType;
   }
 
   @override
   void set type(DartType inferredType) {
     assert(_inferredType == null);
     _inferredType = inferredType;
   }
 
   /**
    * Store the results of type inference for this parameter in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     compilationUnit._storeLinkedType(
-        _unlinkedParam.inferredTypeSlot, _inferredType, _typeParameterContext);
+        _unlinkedParam.inferredTypeSlot, _inferredType, _innermostExecutable);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing the parameter of a synthetic setter for a variable
  * resynthesized during linking.
  */
@@ skipping 13 matching lines @@
   ParameterKind get parameterKind => ParameterKind.REQUIRED;
 
   @override
   DartType get type => enclosingElement.computeVariableType();
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
+ * Mixin used by elements that can have parameters.
+ */
+abstract class ParameterParentElementForLink implements Element {
+  List<ParameterElementForLink> _parameters;
+
+  /**
+   * Get the appropriate integer list to store in
+   * [EntityRef.implicitFunctionTypeIndices] to refer to this element.  For an
+   * element representing a function-typed parameter, this should return a
+   * non-empty list.  For an element representing an executable, this should
+   * return the empty list.
+   */
+  List<int> get implicitFunctionTypeIndices;
+
+  /**
+   * Get the innermost enclosing ExecutableElement (which may be [this], or may
+   * be a parent when there are function-typed parameters).
+   */
+  ExecutableElementForLink get innermostExecutable;
+
+  /**
+   * Get all the parameters of this element.
+   */
+  List<ParameterElementForLink> get parameters {
+    if (_parameters == null) {
+      List<UnlinkedParam> unlinkedParameters = this.unlinkedParameters;
+      int numParameters = unlinkedParameters.length;
+      _parameters = new List<ParameterElementForLink>(numParameters);
+      for (int i = 0; i < numParameters; i++) {
+        UnlinkedParam unlinkedParam = unlinkedParameters[i];
+        _parameters[i] = new ParameterElementForLink(this, unlinkedParam,
+            innermostExecutable, innermostExecutable.enclosingUnit, i);
+      }
+    }
+    return _parameters;
+  }
+
+  /**
+   * Get the list of unlinked parameters of this element.
+   */
+  List<UnlinkedParam> get unlinkedParameters;
+}
+
+/**
  * Element representing a getter or setter resynthesized from a summary during
  * linking.
  */
 abstract class PropertyAccessorElementForLink
     implements PropertyAccessorElementImpl {
   void link(CompilationUnitElementInBuildUnit compilationUnit);
 }
 
 /**
  * Specialization of [PropertyAccessorElementForLink] for non-synthetic
@@ skipping 894 matching lines @@
       if (type is InterfaceType) {
         Element result = type.lookUpGetter(name, compilationUnit.library);
         result ??= type.lookUpMethod(name, compilationUnit.library);
         return result;
       }
     }
     // TODO(scheglov): implement for propagated types
     return null;
   }
 }