Implements support for ignoring method type arguments in resolution.

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

 // Copyright (c) 2013, 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.modelx;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_constructors.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/messages.dart' show MessageTemplate;
 import '../ordered_typeset.dart' show OrderedTypeSet;
 import '../resolution/class_members.dart' show ClassMemberMixin;
 import '../resolution/scope.dart'
-    show ClassScope, LibraryScope, Scope, TypeDeclarationScope;
+    show
+        ClassScope,
+        LibraryScope,
+        Scope,
+        TypeDeclarationScope;
 import '../resolution/resolution.dart' show AnalyzableElementX;
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../resolution/typedefs.dart' show TypedefCyclicVisitor;
 import '../script.dart';
 import '../tokens/token.dart' show ErrorToken, Token;
 import '../tokens/token_constants.dart' as Tokens show EOF_TOKEN;
 import '../tree/tree.dart';
 import '../util/util.dart';
 
 import 'common.dart';
@@ skipping 252 matching lines @@
     return visitor.visitErroneousElement(this, arg);
   }
 
   @override
   get isEffectiveTargetMalformed {
     throw new UnsupportedError("isEffectiveTargetMalformed");
   }
 
   @override
   bool get isFromEnvironmentConstructor => false;
+
+  @override
+  List<DartType> get typeVariables => unsupported();
 }
 
 /// A constructor that was synthesized to recover from a compile-time error.
 class ErroneousConstructorElementX extends ErroneousElementX
     with
         PatchMixin<FunctionElement>,
         AnalyzableElementX,
         ConstantConstructorMixin
     implements ConstructorElementX {
   // TODO(ahe): Instead of subclassing [ErroneousElementX], this class should
@@ skipping 1355 matching lines @@
 }
 
 /// [Element] for a parameter-like element.
 class FormalElementX extends ElementX
     with AstElementMixin
     implements FormalElement {
   final VariableDefinitions definitions;
   final Identifier identifier;
   DartType typeCache;
 
+  @override
+  List<DartType> get typeVariables => functionSignature.typeVariables;
+
   /**
    * Function signature for a variable with a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    */
   FunctionSignature _functionSignatureCache;
 
   FormalElementX(ElementKind elementKind, FunctionTypedElement enclosingElement,
       this.definitions, Identifier identifier)
       : this.identifier = identifier,
@@ skipping 209 matching lines @@
     return getter != null && getter.isAbstract ||
         setter != null && setter.isAbstract;
   }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 // TODO(karlklose): all these lists should have element type [FormalElement].
 class FunctionSignatureX extends FunctionSignatureCommon
     implements FunctionSignature {
+  final List<DartType> typeVariables;
   final List<Element> requiredParameters;
   final List<Element> optionalParameters;
   final int requiredParameterCount;
   final int optionalParameterCount;
   final bool optionalParametersAreNamed;
   final List<Element> orderedOptionalParameters;
   final FunctionType type;
   final bool hasOptionalParameters;
 
   FunctionSignatureX(
-      {this.requiredParameters: const <Element>[],
+      {this.typeVariables: const <DartType>[],
+      this.requiredParameters: const <Element>[],
       this.requiredParameterCount: 0,
       List<Element> optionalParameters: const <Element>[],
       this.optionalParameterCount: 0,
       this.optionalParametersAreNamed: false,
       this.orderedOptionalParameters: const <Element>[],
       this.type})
       : optionalParameters = optionalParameters,
         hasOptionalParameters = !optionalParameters.isEmpty;
 }
 
@@ skipping 60 matching lines @@
   }
 
   FunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
   }
 
   FunctionElement asFunctionElement() => this;
 
+  @override
+  Scope buildScope() => new TypeDeclarationScope(super.buildScope(), this);
+
   String toString() {
     if (isPatch) {
       return 'patch ${super.toString()}';
     } else if (isPatched) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 
   bool get isAbstract => false;
 
   // A function is defined by the implementation element.
   AstElement get definingElement => implementation;
+
+  @override
+  List<DartType> get typeVariables => functionSignature.typeVariables;
 }
 
 abstract class FunctionElementX extends BaseFunctionElementX
     with AnalyzableElementX
     implements MethodElement {
   FunctionElementX(
       String name, ElementKind kind, Modifiers modifiers, Element enclosing)
       : super(name, kind, modifiers, enclosing);
 
   MemberElement get memberContext => this;
@@ skipping 137 matching lines @@
     }
   }
 
   bool get isFromEnvironmentConstructor {
     return name == 'fromEnvironment' &&
         library.isDartCore &&
         (enclosingClass.name == 'bool' ||
             enclosingClass.name == 'int' ||
             enclosingClass.name == 'String');
   }
+
+  /// Returns the empty list of type variables by default.
+  @override
+  List<DartType> get typeVariables => functionSignature.typeVariables;
 }
 
 abstract class ConstructorElementX extends FunctionElementX
     with ConstantConstructorMixin
     implements ConstructorElement {
   bool isRedirectingGenerative = false;
 
   ConstructorElementX(
       String name, ElementKind kind, Modifiers modifiers, Element enclosing)
       : super(name, kind, modifiers, enclosing);
@@ skipping 940 matching lines @@
 
 class TypeVariableElementX extends ElementX
     with AstElementMixin
     implements TypeVariableElement {
   final int index;
   final Node node;
   TypeVariableType typeCache;
   DartType boundCache;
 
   TypeVariableElementX(
-      String name, TypeDeclarationElement enclosing, this.index, this.node)
+      String name, GenericElement enclosing, this.index, this.node)
       : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
-  TypeDeclarationElement get typeDeclaration => enclosingElement;
+  GenericElement get typeDeclaration => enclosingElement;
 
   TypeVariableType computeType(Resolution resolution) => type;
 
   TypeVariableType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been set on $this."));
     return typeCache;
   }
 
   DartType get bound {
@@ skipping 143 matching lines @@
     if (definingElement.isField) {
       FieldElement field = definingElement;
       body = field.initializer;
     } else if (node != null && node.asFunctionExpression() != null) {
       body = node.asFunctionExpression().body;
     }
     return new ParsedResolvedAst(
         declaration, node, body, definingElement.treeElements);
   }
 }