Implement substitution for type variables.

sdk/lib/_internal/compiler/implementation/lib/js_helper.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 _js_helper;
 
 import 'dart:collection';
 import 'dart:collection-dev';
 import 'dart:_foreign_helper' show DART_CLOSURE_TO_JS,
                                    JS,
                                    JS_CALL_IN_ISOLATE,
                                    JS_CURRENT_ISOLATE,
                                    JS_OPERATOR_IS_PREFIX,
+                                   JS_OPERATOR_AS_PREFIX,
                                    JS_HAS_EQUALS,
                                    RAW_DART_FUNCTION_REF,
                                    UNINTERCEPTED;
 
 part 'constant_map.dart';
 part 'native_helper.dart';
 part 'regexp_helper.dart';
 part 'string_helper.dart';
 
 bool isJsArray(var value) {
@@ skipping 1023 matching lines @@
 }
 
 setRuntimeTypeInfo(target, typeInfo) {
   assert(typeInfo == null || isJsArray(typeInfo));
   // We have to check for null because factories may return null.
   if (target != null) JS('var', r'#.$builtinTypeInfo = #', target, typeInfo);
 }
 
 getRuntimeTypeInfo(target) {
   if (target == null) return null;
-  var res = JS('var', r'#.$builtinTypeInfo', target);
-  // If the object does not have runtime type information, return an
-  // empty literal, to avoid null checks.
-  // TODO(ngeoffray): Make the object a top-level field to avoid
-  // allocating a new object every single time.
-  return (res == null) ? JS('var', '{}') : res;
+  return JS('var', r'#.$builtinTypeInfo', target);
+}
+
+getRuntimeTypeArgument(target, index) {
+  var rti = getRuntimeTypeInfo(target);
+  return (rti != null) ? JS('var', r'#[#]', rti, index) : null;
 }
 
 /**
  * The following methods are called by the runtime to implement
  * checked mode and casts. We specialize each primitive type (eg int, bool), and
  * use the compiler's convention to do is-checks on regular objects.
  */
 boolConversionCheck(value) {
   boolTypeCheck(value);
   assert(value != null);
@@ skipping 341 matching lines @@
   bool operator ==(other) {
     if (other is !TypeImpl) return false;
     return typeName == other.typeName;
   }
 }
 
 String getClassName(var object) {
   return JS('String', r'#.constructor.builtin$cls', object);
 }
 
-String getTypeArgumentAsString(List runtimeType) {
+String getRuntimeTypeAsString(List runtimeType) {
   String className = getConstructorName(runtimeType[0]);
   if (runtimeType.length == 1) return className;
   return '$className<${joinArguments(runtimeType, 1)}>';
 }
 
 String getConstructorName(type) => JS('String', r'#.builtin$cls', type);
 
 String runtimeTypeToString(type) {
   if (type == null) {
     return 'dynamic';
   } else if (isJsArray(type)) {
     // A list representing a type with arguments.
-    return getTypeArgumentAsString(type);
+    return getRuntimeTypeAsString(type);
   } else {
     // A reference to the constructor.
     return getConstructorName(type);
   }
 }
 
 String joinArguments(var types, int startIndex) {
   bool firstArgument = true;
   StringBuffer buffer = new StringBuffer();
   for (int index = startIndex; index < types.length; index++) {
     if (firstArgument) {
       firstArgument = false;
     } else {
       buffer. add(', ');
     }
     var argument = types[index];
     buffer.add(runtimeTypeToString(argument));
   }
   return buffer.toString();
 }
 
 String getRuntimeTypeString(var object) {
   String className = isJsArray(object) ? 'List' : getClassName(object);
   var typeInfo = JS('var', r'#.$builtinTypeInfo', object);
   if (typeInfo == null) return className;
   return "$className<${joinArguments(typeInfo, 0)}>";
 }
 
+bool isJsFunction(var o) => JS('bool', r"typeof # == 'function'", o);
+
+Object invoke(function, arguments) {
+  return JS('var', r'#.apply(null, #)', function, arguments);

[ngeoffray, 2013/01/30 13:06:00]

"#(#)" ?

[karlklose, 2013/01/30 15:37:18]

The arguments are in a JS array, but we want them to be passed as separate
arguments to the substitution function.

For example, the fucntion could be
 function (T, U) { return [$.Map, T, U]; }

and we would invoke it with arguments = [$.int, $.String].

+}
+
+/**
+ * Check that the types in the list [arguments] are subtypes of the types in
+ * list [checks] (at the respective positions), possibly applying [substitution]
+ * to the arguments before the check.
+ *
+ * See [:RuntimeTypes.getSubtypeSubstitution:] for a description of the possible
+ * values for [substitution].
+ */
+bool checkArguments(var substitution, var arguments, var checks) {
+  if (isJsArray(substitution)) {
+    arguments = substitution;
+  } else if (isJsFunction(substitution)) {
+    arguments = invoke(substitution, arguments);
+  }
+  return areSubtypes(arguments, checks);
+}
+
+bool areSubtypes(var s, var t) {

[ngeoffray, 2013/01/30 13:06:00]

(var s, var t) -> (List s, List t)

[karlklose, 2013/01/30 15:37:18]

Done.

+  // [:null:] means a raw type.
+  if (s == null || t == null) return true;
+
+  assert(isJsArray(s));
+  assert(isJsArray(t));
+  assert(s.length == t.length);
+
+  int len = s.length;
+  for (int i = 0; i < len; i++) {
+    if (!isSubtype(s[i], t[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+getArguments(var type) => JS('var', r'#.slice(1)', type);
+
+getField(var object, String name) => JS('var', r'#[#]', object, name);
+
 /**
  * Check whether the type represented by [s] is a subtype of the type
  * represented by [t].
  *
  * Type representations can be:
  *  1) a JavaScript constructor for a class C: the represented type is the raw
  *     type C.
  *  2) a JavaScript object: this represents a class for which there is no
  *     JavaScript constructor, because it is only used in type arguments or it
  *     is native. The represented type is the raw type of this class.
  *  3) a JavaScript array: the first entry is of type 1 or 2 and identifies the
  *     class of the type and the rest of the array are the type arguments.
  *  4) [:null:]: the dynamic type.
  */
 bool isSubtype(var s, var t) {
   // If either type is dynamic, [s] is a subtype of [t].
   if (JS('bool', '# == null', s) || JS('bool', '# == null', t)) return true;
   // Subtyping is reflexive.
   if (JS('bool', '# === #', s, t)) return true;
   // Get the object describing the class and check for the subtyping flag
   // constructed from the type of [t].
   var typeOfS = isJsArray(s) ? s[0] : s;
   var typeOfT = isJsArray(t) ? t[0] : t;
+  // Check for a subtyping flag.
   var test = '${JS_OPERATOR_IS_PREFIX()}${runtimeTypeToString(typeOfT)}';
-  if (JS('var', r'#[#]', typeOfS, test) == null) return false;
+  if (getField(typeOfS, test) == null) return false;
   // The class of [s] is a subclass of the class of [t]. If either of the types
   // is raw, [s] is a subtype of [t].
   if (!isJsArray(s) || !isJsArray(t)) return true;
+  // Get the necessary substitution of the type arguments, if there is one.
+  var substitution;
+  if (JS('bool', '# !== #', typeOfT, typeOfS)) {

[ngeoffray, 2013/01/30 13:06:00]

Can we use Dart's "!=" for typeOfT and typeOfS?

[karlklose, 2013/01/30 15:37:18]

I don't think so, as it would try to call $eq on a JS function object.

+    var field = '${JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}';
+    substitution = getField(typeOfS, field);
+  }
   // Recursively check the type arguments.
-  int len = s.length;
-  if (len != t.length) return false;
-  for (int i = 1; i < len; i++) {
-    if (!isSubtype(s[i], t[i])) {
-      return false;
-    }
-  }
-  return true;
+  return checkArguments(substitution, getArguments(s), getArguments(t));
 }
 
 createRuntimeType(String name) => new TypeImpl(name);