Reapply "Enable full type-checks in checked mode."

sdk/lib/_internal/compiler/implementation/lib/js_rti.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.
 
 part of _js_helper;
 
 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);
@@ skipping 101 matching lines @@
  * Parameters:
  * - [isField]: the name of the flag/function to check if the object
  *   is of the correct class.
  * - [checks]: the (JavaScript) list of type representations for the
  *   arguments to check against.
  * - [asField]: the name of the function that transforms the type
  *   arguments of [objects] to an instance of the class that we check
  *   against.
  */
 bool checkSubtype(Object object, String isField, List checks, String asField) {
-  if (object == null) return false;
+  if (object == null) return true;
   var arguments = getRuntimeTypeInfo(object);
   // Interceptor is needed for JSArray and native classes.
   // TODO(sra): It could be a more specialized interceptor since [object] is not
   // `null` or a primitive.
   // TODO(9586): Move type info for static functions onto an interceptor.
-  var interceptor = isJsFunction(object) ? object : getInterceptor(object);
+  var interceptor = getInterceptor(object);
   bool isSubclass = getField(interceptor, isField);
   // When we read the field and it is not there, [isSubclass] will be [:null:].
   if (isSubclass == null || !isSubclass) return false;
   // Should the asField function be passed the receiver?
   var substitution = getField(interceptor, asField);
   return checkArguments(substitution, arguments, checks);
 }
 
+Object assertSubtype(Object object, String isField, List checks,
+                     String asField) {
+  if (!checkSubtype(object, isField, checks, asField)) {
+    // Shorten the field name to the class name and append the textual
+    // representation of the type arguments.
+    int prefixLength = JS_OPERATOR_IS_PREFIX().length;
+    String typeName = '${isField.substring(prefixLength, isField.length)}'
+                      '${joinArguments(checks, 0)}';
+    throw new TypeErrorImplementation(object, typeName);
+  }
+  return object;
+}
+
 /**
  * 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);
@@ skipping 20 matching lines @@
   return isJsArray(type) ? JS('var', r'#.slice(1)', type) : null;
 }
 
 getField(var object, var name) => JS('var', r'#[#]', object, name);
 
 /**
  * Tests whether the Dart object [o] is a subtype of the runtime type
  * representation [t], which is a type representation as described in the
  * comment on [isSubtype].
  */
-bool objectIsSubtype(Object o, var t) {
+bool checkSubtypeOfRuntimeType(Object o, var t) {
   if (JS('bool', '# == null', o) || JS('bool', '# == null', t)) return true;
   // Get the runtime type information from the object here, because we may
   // overwrite o with the interceptor below.
   var rti = getRuntimeTypeInfo(o);
   // Check for native objects and use the interceptor instead of the object.
   // TODO(9586): Move type info for static functions onto an interceptor.
   o = isJsFunction(o) ? o : getInterceptor(o);
   // We can use the object as its own type representation because we install
   // the subtype flags and the substitution on the prototype, so they are
   // properties of the object in JS.
   var type;
   if (JS('bool', '# != null', rti)) {
     // If the type has type variables (that is, [:rti != null:]), make a copy of
     // the type arguments and insert [o] in the first position to create a
     // compound type representation.
     type = JS('List', '#.slice()', rti);
     JS('', '#.splice(0, 0, #)', type, o);
   } else {
     // Use the object as representation of the raw type.
     type = o;
   }
   return isSubtype(type, t);
 }
 
+Object assertSubtypeOfRuntimeType(Object object, var type) {
+  if (!checkSubtypeOfRuntimeType(object, type)) {
+    throw new TypeErrorImplementation(object, runtimeTypeToString(type));
+  }
+  return object;
+}
+
 /**
  * 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 Dart object: this is the interceptor instance for a native type.
  *  3) 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.
  *  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;
   // 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;
+  // TODO(johnniwinther): replace this with the real function subtype test.
+  if (JS('bool', '#.func', s) == true || JS('bool', '#.func', t) == true ) {
+    return true;
+  }
   // 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));
 }
 
 createRuntimeType(String name) => new TypeImpl(name);