Adjusts dart2js backend to handle method type arguments.

pkg/compiler/lib/src/dart_types.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 dart_types;
 
 import 'dart:math' show min;
 
 import 'common/resolution.dart' show Resolution;
 import 'common.dart';
 import 'core_types.dart';
 import 'elements/elements.dart';
-import 'elements/modelx.dart' show TypeDeclarationElementX;
+import 'elements/modelx.dart' show TypeDeclarationElementX, ErroneousElementX;
 import 'ordered_typeset.dart' show OrderedTypeSet;
 import 'util/util.dart' show equalElements;
 
 enum TypeKind {
   FUNCTION,
   INTERFACE,
   STATEMENT,
   TYPEDEF,
   TYPE_VARIABLE,
   MALFORMED_TYPE,
@@ skipping 93 matching lines @@
   /// Is [: true :] if this type is a typedef.
   bool get isTypedef => kind == TypeKind.TYPEDEF;
 
   /// Is [: true :] if this type is a function type.
   bool get isFunctionType => kind == TypeKind.FUNCTION;
 
   /// Is [: true :] if this type is a type variable.
   bool get isTypeVariable => kind == TypeKind.TYPE_VARIABLE;
 
   /// Is [: true :] if this type is a malformed type.
-  bool get isMalformed => kind == TypeKind.MALFORMED_TYPE;
+  bool get isMalformed => false;
 
   /// Is `true` if this type is declared by an enum.
   bool get isEnumType => false;
 
   /// Returns an occurrence of a type variable within this type, if any.
   TypeVariableType get typeVariableOccurrence => null;
 
   /// Applies [f] to each occurence of a [TypeVariableType] within this type.
   void forEachTypeVariable(f(TypeVariableType variable)) {}
 
@@ skipping 19 matching lines @@
   accept(DartTypeVisitor visitor, var argument);
 
   void visitChildren(DartTypeVisitor visitor, var argument) {}
 
   static void visitList(
       List<DartType> types, DartTypeVisitor visitor, var argument) {
     for (DartType type in types) {
       type.accept(visitor, argument);
     }
   }
+
+  /// Returns a [DartType] which corresponds to [this] except that each
+  /// contained [MethodTypeVariableType] is replaced by a [DynamicType].
+  /// GENERIC_METHODS: Temporary, only used with '--generic-method-syntax'.
+  DartType get dynamifyMethodTypeVariableType => this;
+
+  /// Returns true iff [this] is or contains a [MethodTypeVariableType].
+  /// GENERIC_METHODS: Temporary, only used with '--generic-method-syntax'
+  bool get containsMethodTypeVariableType => false;
 }
 
 /**
  * Represents a type variable, that is the type parameters of a class type.
  *
  * For example, in [: class Array<E> { ... } :], E is a type variable.
  *
  * Each class should have its own unique type variables, one for each type
  * parameter. A class with type parameters is said to be parameterized or
  * generic.
@@ skipping 50 matching lines @@
   int get hashCode => 17 * element.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableType) return false;
     return identical(other.element, element);
   }
 
   String toString() => name;
 }
 
+/// Provides a thin model of method type variables: They are treated as if
+/// their value were `dynamic` when used in a type annotation, and as a
+/// malformed type when used in an `as` or `is` expression.
+class MethodTypeVariableType extends TypeVariableType {
+  MethodTypeVariableType(TypeVariableElement element) : super(element);
+
+  @override
+  bool get treatAsDynamic => true;
+
+  @override
+  bool get isMalformed => true;
+
+  @override
+  DartType get dynamifyMethodTypeVariableType => const DynamicType();
+
+  @override
+  get containsMethodTypeVariableType => true;
+
+  ErroneousElement get toMalformedElement =>

[Johnni Winther, 2016/05/23 12:50:41]

Remove this (unused)

[eernst, 2016/05/23 14:30:24]

(OK, unused after fixing constructor.dart:739), done.

+      new ErroneousElementX(
+          MessageKind.TYPE_VARIABLE_FROM_METHOD_NOT_REIFIED,
+          const {},
+          element.name,
+          element.typeDeclaration);
+}
+
 /// Internal type representing the result of analyzing a statement.
 class StatementType extends DartType {
   Element get element => null;
 
   TypeKind get kind => TypeKind.STATEMENT;
 
   String get name => 'statement';
 
   const StatementType();
 
@@ skipping 59 matching lines @@
   String get name => element.name;
 
   DartType subst(List<DartType> arguments, List<DartType> parameters) {
     // Malformed types are not substitutable.
     return this;
   }
 
   // Malformed types are treated as dynamic.
   bool get treatAsDynamic => true;
 
+  @override
+  bool get isMalformed => true;
+
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitMalformedType(this, argument);
   }
 
   String toString() {
     var sb = new StringBuffer();
     if (typeArguments != null) {
       if (userProvidedBadType != null) {
         sb.write(userProvidedBadType.name);
       } else {
         sb.write(element.name);
       }
       if (!typeArguments.isEmpty) {
         sb.write('<');
         sb.write(typeArguments.join(', '));
         sb.write('>');
       }
     } else {
       sb.write(userProvidedBadType.toString());
     }
     return sb.toString();
   }
 }
 
 abstract class GenericType extends DartType {
   final TypeDeclarationElement element;
   final List<DartType> typeArguments;
 
-  GenericType(TypeDeclarationElement element, this.typeArguments,
+  GenericType(TypeDeclarationElement element, List<DartType> typeArguments,
       {bool checkTypeArgumentCount: true})
-      : this.element = element {
+      : this.element = element,
+        this.typeArguments = typeArguments,
+        this.containsMethodTypeVariableType =
+            typeArguments.any(_typeContainsMethodTypeVariableType)
+  {
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, element != null,
         message: "Missing element for generic type."));
     assert(invariant(element, () {
       if (!checkTypeArgumentCount) return true;
       if (element is TypeDeclarationElementX) {
         return element.thisTypeCache == null ||
             typeArguments.length == element.typeVariables.length;
       }
       return true;
     },
@@ skipping 41 matching lines @@
     StringBuffer sb = new StringBuffer();
     sb.write(name);
     if (!isRaw) {
       sb.write('<');
       sb.write(typeArguments.join(', '));
       sb.write('>');
     }
     return sb.toString();
   }
 
+  @override
+  final bool containsMethodTypeVariableType;
+
+  @override
+  DartType get dynamifyMethodTypeVariableType {
+    if (!containsMethodTypeVariableType) return this;
+    List<DartType> newTypeArguments = typeArguments.map(
+        (DartType type) => type.dynamifyMethodTypeVariableType).toList();
+    return createInstantiation(newTypeArguments);
+  }
+
   int get hashCode {
     int hash = element.hashCode;
     for (DartType argument in typeArguments) {
       int argumentHash = argument != null ? argument.hashCode : 0;
       hash = 17 * hash + 3 * argumentHash;
     }
     return hash;
   }
 
   bool operator ==(other) {
@@ skipping 161 matching lines @@
       [DartType returnType = const DynamicType(),
       List<DartType> parameterTypes = const <DartType>[],
       List<DartType> optionalParameterTypes = const <DartType>[],
       List<String> namedParameters = const <String>[],
       List<DartType> namedParameterTypes = const <DartType>[]]) {
     return new FunctionType.internal(null, returnType, parameterTypes,
         optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
   FunctionType.internal(FunctionTypedElement this.element,
-      [DartType this.returnType = const DynamicType(),
-      this.parameterTypes = const <DartType>[],
-      this.optionalParameterTypes = const <DartType>[],
-      this.namedParameters = const <String>[],
-      this.namedParameterTypes = const <DartType>[]]) {
+      [DartType returnType = const DynamicType(),
+      List<DartType> parameterTypes = const <DartType>[],
+      List<DartType> optionalParameterTypes = const <DartType>[],
+      List<String> namedParameters = const <String>[],
+      List<DartType> namedParameterTypes = const <DartType>[]])
+      : this.returnType = returnType,
+        this.parameterTypes = parameterTypes,
+        this.optionalParameterTypes = optionalParameterTypes,
+        this.namedParameters = namedParameters,
+        this.namedParameterTypes = namedParameterTypes,
+        this.containsMethodTypeVariableType =
+          returnType.containsMethodTypeVariableType ||
+          parameterTypes.any(_typeContainsMethodTypeVariableType) ||
+          optionalParameterTypes.any(_typeContainsMethodTypeVariableType) ||
+          namedParameterTypes.any(_typeContainsMethodTypeVariableType) {
     assert(invariant(
         CURRENT_ELEMENT_SPANNABLE, element == null || element.isDeclaration));
     // Assert that optional and named parameters are not used at the same time.
     assert(optionalParameterTypes.isEmpty || namedParameterTypes.isEmpty);
     assert(namedParameters.length == namedParameterTypes.length);
   }
 
   TypeKind get kind => TypeKind.FUNCTION;
 
   DartType getNamedParameterType(String name) {
@@ skipping 107 matching lines @@
       sb.write('}');
     }
     sb.write(') -> ${returnType}');
     return sb.toString();
   }
 
   String get name => 'Function';
 
   int computeArity() => parameterTypes.length;
 
+  @override
+  DartType get dynamifyMethodTypeVariableType {
+    if (!containsMethodTypeVariableType) return this;
+    DartType eraseIt(DartType type) => type.dynamifyMethodTypeVariableType;
+    DartType newReturnType = returnType.dynamifyMethodTypeVariableType;
+    List<DartType> newParameterTypes = parameterTypes.map(eraseIt).toList();
+    List<DartType> newOptionalParameterTypes =
+        optionalParameterTypes.map(eraseIt).toList();
+    List<DartType> newNamedParameterTypes =
+        namedParameterTypes.map(eraseIt).toList();
+    return new FunctionType.internal(
+        element,
+        newReturnType,
+        newParameterTypes,
+        newOptionalParameterTypes,
+        namedParameters,
+        newNamedParameterTypes);
+  }
+
+  @override
+  final bool containsMethodTypeVariableType;
+
   int get hashCode {
     int hash = 3 * returnType.hashCode;
     for (DartType parameter in parameterTypes) {
       hash = 17 * hash + 5 * parameter.hashCode;
     }
     for (DartType parameter in optionalParameterTypes) {
       hash = 19 * hash + 7 * parameter.hashCode;
     }
     for (String name in namedParameters) {
       hash = 23 * hash + 11 * name.hashCode;
     }
     for (DartType parameter in namedParameterTypes) {
       hash = 29 * hash + 13 * parameter.hashCode;
     }
     return hash;
   }
 
   bool operator ==(other) {
     if (other is! FunctionType) return false;
     return returnType == other.returnType &&
         equalElements(parameterTypes, other.parameterTypes) &&
         equalElements(optionalParameterTypes, other.optionalParameterTypes) &&
         equalElements(namedParameters, other.namedParameters) &&
         equalElements(namedParameterTypes, other.namedParameterTypes);
   }
 }
 
+bool _typeContainsMethodTypeVariableType(DartType type) =>
+    type.containsMethodTypeVariableType;
+
 class TypedefType extends GenericType {
   DartType _unaliased;
 
   TypedefType(TypedefElement element,
       [List<DartType> typeArguments = const <DartType>[]])
       : super(element, typeArguments);
 
   TypedefType.forUserProvidedBadType(TypedefElement element,
       [List<DartType> typeArguments = const <DartType>[]])
       : super(element, typeArguments, checkTypeArgumentCount: false);
@@ skipping 582 matching lines @@
     return changed ? result : types;
   }
 
   /**
    * Returns the [ClassElement] which declares the type variables occurring in
    * [type], or [:null:] if [type] does not contain type variables.
    */
   static ClassElement getClassContext(DartType type) {
     TypeVariableType typeVariable = type.typeVariableOccurrence;
     if (typeVariable == null) return null;
+    // GENERIC_METHODS: When generic method support is complete enough to
+    // include a runtime value for method type variables this must be updated.
+    // For full support the global assumption that all type variables are
+    // declared by the same enclosing class will not hold: Both an enclosing
+    // method and an enclosing class may define type variables, so the return
+    // type cannot be [ClassElement] and the caller must be prepared to look in
+    // two locations, not one. Currently we ignore method type variables by
+    // returning in the next statement.
+    if (typeVariable.element.typeDeclaration is! ClassElement) return null;
     return typeVariable.element.typeDeclaration;
   }
 
   /**
    * A `compareTo` function that globally orders types using
    * [Elements.compareByPosition] to order types defined by a declaration.
    *
    * The order is:
    * * void
    * * dynamic
@@ skipping 561 matching lines @@
           sb.write(', ');
         }
         namedParameterTypes[index].accept(this, namedParameters[index]);
         needsComma = true;
       }
       sb.write('}');
     }
     sb.write(')');
   }
 }