Support runtime check of function types.

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:_foreign_helper' show DART_CLOSURE_TO_JS,
                                    JS,
                                    JS_CALL_IN_ISOLATE,
@@ skipping 1031 matching lines @@
   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;
   return JS('var', r'#.$builtinTypeInfo', target);
 }
 
+forwardRuntimeTypeInfo(target, substitution, source) {
+  setRuntimeTypeInfo(target,
+      substitute(substitution, getRuntimeTypeInfo(source)));
+  return target;
+}
+
 getRuntimeTypeArgument(target, substitution, index) {
   var arguments = substitute(substitution, getRuntimeTypeInfo(target));
   return (arguments == null) ? null : getField(arguments, index);
 }
 
 /**
  * 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.
  */
@@ skipping 403 matching lines @@
 
 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);
 
+bool isJsObject(var o) => JS('bool', r"typeof # == 'object'", o);
+
 Object invoke(function, arguments) {
   return JS('var', r'#.apply(null, #)', function, arguments);
 }
 
 substitute(var substitution, var arguments) {
   if (isJsArray(substitution)) {
     arguments = substitution;
   } else if (isJsFunction(substitution)) {
     arguments = invoke(substitution, arguments);
   }
   return arguments;
 }
 
 /**
  * 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) {
   return areSubtypes(substitute(substitution, arguments), checks);
 }
 
+bool getSignature(var signature, var target) {
+  return invoke(signature, getRuntimeTypeInfo(target));
+}
+
+bool checkFunctionSubtype(var target, var typeSignature, var context) {
+  var targetSignature = getField(target, r'$signature');

[ngeoffray, 2013/03/13 09:30:46]

Using $signature directly is brittle, you should probably add a new JS.

[Johnni Winther, 2013/03/22 07:30:24]

Done.

+  if (targetSignature == null) {
+    // The target is statically known to be a subtype so further check is

[ngeoffray, 2013/03/13 09:30:46]

further or no further? Could you add an example?

[Johnni Winther, 2013/03/22 07:30:24]

Not needed in the new encoding.

+    // needed.
+    return true;
+  }
+  if (isJsFunction(targetSignature)) {
+    targetSignature = invoke(targetSignature, getRuntimeTypeInfo(target));
+  }
+  if (isJsFunction(typeSignature)) {
+    typeSignature = invoke(typeSignature, getRuntimeTypeInfo(context));
+  }
+  return isFunctionSubtype(targetSignature, typeSignature);
+}
+
 bool areSubtypes(List s, List t) {
   // [: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++) {
@@ skipping 54 matching lines @@
  *  4) a JavaScript array: the first entry is of type 1, 2 or 3 and contains the
  *     subtyping flags and the substitution of the type and the rest of the
  *     array are the type arguments.
  *  5) [: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;
+  if (getField(t, 'func') == true) {

[ngeoffray, 2013/03/13 09:30:46]

What is this? Probably needs an abstraction.

[Johnni Winther, 2013/03/22 07:30:24]

A tag used to identify function type representations. 'func' changed to used
foreign helper.

+    return isFunctionSubtype(s, t);
+  }
   // 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 (getField(typeOfS, test) == null) return false;
   // Get the necessary substitution of the type arguments, if there is one.
   var substitution;
   if (JS('bool', '# !== #', typeOfT, typeOfS)) {
     var field = '${JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}';
     substitution = getField(typeOfS, field);
   }
   // The class of [s] is a subclass of the class of [t].  If [s] has no type
   // arguments and no substitution, it is used as raw type.  If [t] has no
   // type arguments, it used as a raw type.  In both cases, [s] is a subtype
   // of [t].
   if ((!isJsArray(s) && JS('bool', '# == null', substitution)) ||
       !isJsArray(t)) {
     return true;
   }
   // Recursively check the type arguments.
   return checkArguments(substitution, getArguments(s), getArguments(t));
 }
 
+bool isAssignable(var s, var t) {
+  return isSubtype(s, t) || isSubtype(t, s);
+}
+
+bool areAssignable(List s, List t, bool allowSubset) {
+  if (t == null) return true;
+  if (s == null) return false;
+
+  assert(isJsArray(s));
+  assert(isJsArray(t));
+
+  if (allowSubset) {
+    if (s.length < t.length) return false;
+  } else {
+    if (s.length != t.length) return false;
+  }
+
+  int len = t.length;
+  for (int i = 0; i < len; i++) {
+    if (!isAssignable(s[i], t[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool areAssignableMaps(var s, var t) {
+  if (t == null) return true;
+  if (s == null) return false;
+
+  assert(isJsObject(s));
+  assert(isJsObject(t));
+
+  // Hack: We need to iterate over the properties in [t], and the names of these
+  // properties are not statically known so they must be retrieved dynamically.
+  // Therefore we (mis)use the [JS] function to generate a for-each loop on [t]
+  // using the JavaScript variable [:$name:] to hold the property names.

[ngeoffray, 2013/03/13 09:30:46]

To not make it a hack, please create a JavaScript closure. We should make sure
all JS are expressions.

[Johnni Winther, 2013/03/22 07:30:24]

How?

+  JS('', r'for (var $name in #) {', t); {
+    // We need to distinguish the existing property with value [:undefined:] or
+    // [:null:] from the non-existing property. The former is interpreted as a
+    // named parameter of type [:dynamic:] and the later is interpreted as
+    // [:$name:] not being a named parameter of [s].
+    if (JS('bool', r'!#.hasOwnProperty($name)', s)) return false;
+    var tType = JS('', r'#[$name]', t);
+    var sType = JS('', r'#[$name]', s);
+    if (!isAssignable(sType, tType)) {
+      return false;
+    }
+  } JS('', '}');
+  return true;
+}
+
+bool isFunctionSubtype(var s, var t) {
+  if (!getField(s, 'func')) return false;
+  if (getField(s, 'retvoid')) {
+    if (!getField(t, 'retvoid')) return false;
+  } else if (!getField(t, 'retvoid')) {
+    var sReturnType = getField(s, 'ret');
+    var tReturnType = getField(t, 'ret');
+    if (!isAssignable(sReturnType, tReturnType)) return false;
+  }
+  var sParameterTypes = getField(s, 'args');
+  var tParameterTypes = getField(t, 'args');
+  if (!areAssignable(sParameterTypes, tParameterTypes, false)) return false;
+  var sOptionalParameterTypes = getField(s, 'opt');
+  var tOptionalParameterTypes = getField(t, 'opt');
+  if (!areAssignable(sOptionalParameterTypes, tOptionalParameterTypes, true)) {
+    return false;
+  }
+  var sNamedParameters = getField(s, 'named');
+  var tNamedParameters = getField(t, 'named');
+  if (!areAssignableMaps(sNamedParameters, tNamedParameters)) return false;
+  return true;
+}
+
 createRuntimeType(String name) => new TypeImpl(name);