Implements support for ignoring method type arguments in resolution.

pkg/compiler/lib/src/elements/elements.dart

 // Copyright (c) 2012, 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 elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart';
@@ skipping 1082 matching lines @@
  * looking at code like "foo.x", we don't have to look for both a
  * field named "x", a getter named "x", and a setter named "x=".
  */
 abstract class AbstractFieldElement extends Element {
   GetterElement get getter;
   SetterElement get setter;
 }
 
 abstract class FunctionSignature {
   FunctionType get type;
+  List<DartType> get typeVariables;
   List<FormalElement> get requiredParameters;
   List<FormalElement> get optionalParameters;
 
   int get requiredParameterCount;
   int get optionalParameterCount;
   bool get optionalParametersAreNamed;
   bool get hasOptionalParameters;
 
   int get parameterCount;
   List<FormalElement> get orderedOptionalParameters;
 
   void forEachParameter(void function(FormalElement parameter));
   void forEachRequiredParameter(void function(FormalElement parameter));
   void forEachOptionalParameter(void function(FormalElement parameter));
 
   void orderedForEachParameter(void function(FormalElement parameter));
 
   bool isCompatibleWith(FunctionSignature constructorSignature);
 }
 
 /// A top level, static or instance method, constructor, local function, or
 /// closure (anonymous local function).
 abstract class FunctionElement extends Element
     implements
         AstElement,
         TypedElement,
         FunctionTypedElement,
-        ExecutableElement {
+        ExecutableElement,
+        GenericElement {
   FunctionExpression get node;
 
   FunctionElement get patch;
   FunctionElement get origin;
 
   bool get hasFunctionSignature;
 
-  /// The parameters of this functions.
+  /// The parameters of this function.
   List<ParameterElement> get parameters;
 
   /// The type of this function.
   FunctionType get type;
 
   /// The synchronous/asynchronous marker on this function.
   AsyncMarker get asyncMarker;
 
   /// `true` if this function is external.
   bool get isExternal;
@@ skipping 159 matching lines @@
   @deprecated
   get enclosingElement;
 }
 
 /// JavaScript backend specific element for the body of constructor.
 // TODO(johnniwinther): Remove this class from the element model.
 abstract class ConstructorBodyElement extends MethodElement {
   FunctionElement get constructor;
 }
 
+/// [GenericElement] defines the common interface for generic functions and
+/// [TypeDeclarationElement].
+abstract class GenericElement extends Element implements AstElement {
+  /**
+   * The type variables declared on this declaration. The type variables are not
+   * available until the type of the element has been computed through
+   * [computeType].
+   */
+  List<DartType> get typeVariables;
+}
+
 /// [TypeDeclarationElement] defines the common interface for class/interface
 /// declarations and typedefs.
-abstract class TypeDeclarationElement extends Element implements AstElement {
+abstract class TypeDeclarationElement extends GenericElement {
   /// The name of this type declaration, taking privacy into account.
   Name get memberName;
 
   /// Do not use [computeType] outside of the resolver; instead retrieve the
   /// type from the [thisType] or [rawType], depending on the use case.
   ///
   /// Trying to access a type that has not been computed in resolution is an
   /// error and calling [computeType] covers that error.
   /// This method will go away!
   @deprecated
@@ skipping 21 matching lines @@
    * The [rawType] field is a canonicalization of the raw type and should be
    * used to distinguish explicit and implicit uses of the [dynamic]
    * type arguments. For instance should [:List:] be the [rawType] of the
    * [:List:] class element whereas [:List<dynamic>:] should be its own
    * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
    * this distinction, we can print the raw type with type arguments only when
    * the input source has used explicit type arguments.
    */
   GenericType get rawType;
 
-  /**
-   * The type variables declared on this declaration. The type variables are not
-   * available until the type of the element has been computed through
-   * [computeType].
-   */
-  List<DartType> get typeVariables;
-
   bool get isResolved;
 
   void ensureResolved(Resolution resolution);
 }
 
 abstract class ClassElement extends TypeDeclarationElement
     implements ScopeContainerElement {
   /// The length of the longest inheritance path from [:Object:].
   int get hierarchyDepth;
 
@@ skipping 176 matching lines @@
 /// The [Element] for a type variable declaration on a generic class or typedef.
 abstract class TypeVariableElement extends Element
     implements AstElement, TypedElement {
   /// The name of this type variable, taking privacy into account.
   Name get memberName;
 
   /// Use [typeDeclaration] instead.
   @deprecated
   get enclosingElement;
 
-  /// The class or typedef on which this type variable is defined.
-  TypeDeclarationElement get typeDeclaration;
+  /// The class, typedef, function, or method on which this type variable is

[Johnni Winther, 2016/04/29 07:21:06]

or function typed parameter

[eernst, 2016/04/29 13:24:50]

Done.

+  /// defined.
+  GenericElement get typeDeclaration;
 
   /// The index of this type variable within its type declaration.
   int get index;
 
   /// The [type] defined by the type variable.
   TypeVariableType get type;
 
   /// The upper bound on the type variable. If not explicitly declared, this is
   /// `Object`.
   DartType get bound;
@@ skipping 21 matching lines @@
   /// Trying to access a type that has not been computed in resolution is an
   /// error and calling [computeType] covers that error.
   /// This method will go away!
   @deprecated
   DartType computeType(Resolution resolution);
 
   DartType get type;
 }
 
 /// An [Element] that can define a function type.
-abstract class FunctionTypedElement extends Element {
+abstract class FunctionTypedElement extends Element implements GenericElement {
   /// The function signature for the function type defined by this element,
   /// if any.
   FunctionSignature get functionSignature;
 }
 
 /// An [Element] that holds a [TreeElements] mapping.
 abstract class AnalyzableElement extends Element {
   /// Return `true` if [treeElements] have been (partially) computed for this
   /// element.
   bool get hasTreeElements;
@@ skipping 175 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }