Support runtime check of function types.

sdk/lib/_internal/compiler/implementation/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 'dart2jslib.dart' show Compiler, invariant, Script, Message;
 import 'elements/modelx.dart'
     show VoidElementX, LibraryElementX, BaseClassElementX;
 import 'elements/elements.dart';
@@ skipping 890 matching lines @@
     }
     return cachedType;
   }
 
   String toString() {
     return '$receiver.${element.name.slowToString()}';
   }
 }
 
 abstract class DartTypeVisitor<R, A> {
+  const DartTypeVisitor();
+
   R visitType(DartType type, A argument);
 
   R visitVoidType(VoidType type, A argument) =>
       visitType(type, argument);
 
   R visitTypeVariableType(TypeVariableType type, A argument) =>
       visitType(type, argument);
 
   R visitFunctionType(FunctionType type, A argument) =>
       visitType(type, argument);
@@ skipping 10 matching lines @@
   R visitInterfaceType(InterfaceType type, A argument) =>
       visitGenericType(type, argument);
 
   R visitTypedefType(TypedefType type, A argument) =>
       visitGenericType(type, argument);
 
   R visitDynamicType(DynamicType type, A argument) =>
       visitInterfaceType(type, argument);
 }
 
+/**
+ * Type visitor that determines the subtype relation two types.
+ */
 class SubtypeVisitor extends DartTypeVisitor<bool, DartType> {
   final Compiler compiler;
   final DynamicType dynamicType;
   final VoidType voidType;
 
   SubtypeVisitor(Compiler this.compiler,
                  DynamicType this.dynamicType,
                  VoidType this.voidType);
 
   bool isSubtype(DartType t, DartType s) {
@@ skipping 182 matching lines @@
     return isSubtype(bound, s);
   }
 }
 
 class Types {
   final Compiler compiler;
   // TODO(karlklose): should we have a class Void?
   final VoidType voidType;
   final DynamicType dynamicType;
   final SubtypeVisitor subtypeVisitor;
+  final PotentialSubtypeVisitor potentialSubtypeVisitor;
 
   factory Types(Compiler compiler, BaseClassElementX dynamicElement) {
     LibraryElement library = new LibraryElementX(new Script(null, null));
     VoidType voidType = new VoidType(new VoidElementX(library));
     DynamicType dynamicType = new DynamicType(dynamicElement);
     dynamicElement.rawTypeCache = dynamicElement.thisType = dynamicType;
     SubtypeVisitor subtypeVisitor =
         new SubtypeVisitor(compiler, dynamicType, voidType);
-    return new Types.internal(compiler, voidType, dynamicType, subtypeVisitor);
+    PotentialSubtypeVisitor potentialSubtypeVisitor =
+        new PotentialSubtypeVisitor(compiler, dynamicType, voidType);
+
+    return new Types.internal(compiler, voidType, dynamicType,
+        subtypeVisitor, potentialSubtypeVisitor);
   }
 
   Types.internal(this.compiler, this.voidType, this.dynamicType,
-                 this.subtypeVisitor);
+                 this.subtypeVisitor, this.potentialSubtypeVisitor);
 
   /** Returns true if t is a subtype of s */
   bool isSubtype(DartType t, DartType s) {
     return subtypeVisitor.isSubtype(t, s);
   }
 
   bool isAssignable(DartType r, DartType s) {
     return subtypeVisitor.isAssignable(r, s);
   }
 
+  bool isPotentialSubtype(DartType t, DartType s) {
+    // TODO(johnniwinther): Return a set of variable points in the positive
+    // cases.
+    return potentialSubtypeVisitor.isSubtype(t, s);
+  }
 
   /**
    * Helper method for performing substitution of a linked list of types.
    *
    * If no types are changed by the substitution, the [types] is returned
    * instead of a newly created linked list.
    */
   static Link<DartType> substTypes(Link<DartType> types,
                                    Link<DartType> arguments,
                                    Link<DartType> parameters) {
@@ skipping 34 matching lines @@
   /**
    * 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;
     return typeVariable.element.enclosingElement;
   }
 }
+
+/**
+ * Type visitor that determines one type could a subtype of another given the
+ * right type variable substitution. The computation is approximate and returns
+ * [:false:] only if we are sure no such substitution exists.
+ */
+class PotentialSubtypeVisitor extends SubtypeVisitor {
+  PotentialSubtypeVisitor(Compiler compiler,
+                          DynamicType dynamicType,
+                          VoidType voidType)
+      : super(compiler, dynamicType, voidType);
+
+
+  bool isSubtype(DartType t, DartType s) {
+    if (t is TypeVariableType || s is TypeVariableType) {
+      return true;
+    }
+    return super.isSubtype(t, s);
+  }
+}