Fix a bunch of issues with 'hidden' DOM types.

frog/value.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
@@ skipping 275 matching lines @@
       return this;
     }
 
     if (checked && !toType.isSubtypeOf(type)) {
       // According to the static types, this conversion can't work.
       convertWarning(toType, node);
     }
 
     // Generate a runtime checks if they're turned on, otherwise skip it.
     if (options.enableTypeChecks) {
-      return _typeAssert(context, toType, node);
+      return _typeAssert(context, toType, node, isDynamic);
     } else {
       return this;
     }
   }
 
   /**
    * Checks whether [toType] is a callback function, and it is defined in the
    * dom library.
    */
   bool _isDomCallback(toType) {
@@ skipping 17 matching lines @@
       world.gen.corejs.useWrap1 = true;
     }
     return new Value(toType, '\$wrap_call\$$arity($code)', span);
   }
 
   /**
    * Generates a run time type assertion for the given value. This works like
    * [instanceOf], but it allows null since Dart types are nullable.
    * Also it will throw a TypeError if it gets the wrong type.
    */
-  Value _typeAssert(MethodGenerator context, Type toType, Node node) {
+  Value _typeAssert(MethodGenerator context, Type toType, Node node,
+      bool isDynamic) {
     if (toType is ParameterType) {
       ParameterType p = toType;
       toType = p.extendsType;
     }
 
-    // TODO(jmesserly): fix checking of function types, and DOM objects
-    // For now, don't generate a broken check.
-    // (For DOM types to work right, we need to lazily patch the "is$DOMWindow"
-    // check methods, by catching it on Object.prototype like VarMember does)
-    if (toType.getCallMethod() != null || toType.library == world.dom) {
-      return this;
+    if (toType.isObject || toType.isVar) {
+      world.internalError(
+          'We thought ${type.name} is not a subtype of ${toType.name}?');
     }
 
-    if (toType.isObject || toType.isVar) {
-      world.internalError('We thought ${type.name} is not a subtype of ${toType.name}?');
-    }
+    final typeError = world.corelib.types['TypeError'];
+    final typeErrorCtor = typeError.getConstructor('_internal');
+    world.gen.corejs.ensureTypeNameOf();
+    final result = typeErrorCtor.invoke(context, node,
+        new Value.type(typeError, null),
+        new Arguments(null, [
+          new Value(world.objectType, 'this', null),
+          new Value(world.stringType, '"${toType.name}"', null)]),
+        isDynamic);
+    world.gen.corejs.useThrow = true;
+    final throwTypeError = '\$throw(${result.code})';
 
     // TODO(jmesserly): better assert for integers?
     if (toType.isNum) toType = world.numType;
 
     // Generate a check like these:
     //   obj && obj.is$TypeName()
     //   $assert_int(obj)
     //
     // We rely on the fact that calling an undefined method produces a JS
     // TypeError. Alternatively we could define fallbacks on Object that throw.
     String check;
     if (toType.isVoid) {
       check = '\$assert_void($code)';
       if (toType.typeCheckCode == null) {
         toType.typeCheckCode = '''
 function \$assert_void(x) {
-  return x == null ? x : x.is\$void(); // throws TypeError
+  if (x == null) return null;
+  $throwTypeError
 }''';
       }
     } else if (toType == world.nonNullBool) {
       // This could be made less of a special case
       world.gen.corejs.useNotNullBool = true;
       check = '\$notnull_bool($code)';
 
     } else if (toType.library.isCore && toType.typeofName != null) {
       check = '\$assert_${toType.name}($code)';
 
       if (toType.typeCheckCode == null) {
         toType.typeCheckCode = '''
 function \$assert_${toType.name}(x) {
   if (x == null || typeof(x) == "${toType.typeofName}") return x;
-  throw new TypeError("'" + x + "' is not a ${toType.name}.");
+  $throwTypeError
 }''';
       }
     } else {
-      toType.isTested = true;
+      toType.isChecked = true;
+
+      String checkName = 'assert\$' + toType.jsname;
 
       // If we track nullability, we could simplify this check.
       var temp = context.getTemp(this);
-      check = '(${context.assignTemp(temp, this).code} &&';
-      check += ' ${temp.code}.is\$${toType.jsname}())';
+      check = '(${context.assignTemp(temp, this).code} == null ? null :';
+      check += ' ${temp.code}.$checkName())';
       if (this != temp) context.freeTemp(temp);
+
+      // Generate the fallback on Object (that throws a TypeError)
+      if (!world.objectType.varStubs.containsKey(checkName)) {
+        world.objectType.varStubs[checkName] =
+          new VarMethodStub(checkName, null, Arguments.EMPTY, throwTypeError);
+      }
     }
 
     return new Value(toType, check, span);
   }
 
   /**
    * Test to see if value is an instance of this type.
    *
    * - If a primitive type, then uses the JavaScript typeof.
    * - If it's a non-generic class, use instanceof.
@@ skipping 18 matching lines @@
         return new EvaluatedValue(world.nonNullBool, true, 'true', null);
       }
     }
 
     if (toType.library.isCore) {
       var typeofName = toType.typeofName;
       if (typeofName != null) {
         testCode = "(typeof($code) ${isTrue ? '==' : '!='} '$typeofName')";
       }
     }
-    if (toType.isClass && toType is !ConcreteType) {
+    if (toType.isClass && toType is !ConcreteType
+        && !toType.isHiddenNativeType) {
       toType.markUsed();
       testCode = '($code instanceof ${toType.jsname})';
       if (!isTrue) {
         testCode = '!' + testCode;
       }
     }
     if (testCode == null) {
       toType.isTested = true;
 
       // If we track nullability, we could simplify this check.
       var temp = context.getTemp(this);
 
+      String checkName = 'is\$${toType.jsname}';
       testCode = '(${context.assignTemp(temp, this).code} &&';
-      testCode += ' ${temp.code}.is\$${toType.jsname})';
+      testCode += ' ${temp.code}.$checkName())';
       if (isTrue) {
         // Add !! to convert to boolean.
         // TODO(jimhug): only do this if needed
         testCode = '!!' + testCode;
       } else {
         // The single ! here nicely converts undefined to false and function
         // to true.
         testCode = '!' + testCode;
       }
       if (this != temp) context.freeTemp(temp);
+
+      // Generate the fallback on Object (that returns false)
+      if (!world.objectType.varStubs.containsKey(checkName)) {
+        world.objectType.varStubs[checkName] =
+          new VarMethodStub(checkName, null, Arguments.EMPTY, 'return false');
+      }
     }
     return new Value(world.nonNullBool, testCode, span);
   }
 
   void convertWarning(Type toType, Node node) {
     // TODO(jmesserly): better error messages for type conversion failures
     world.warning('type "${type.name}" is not assignable to "${toType.name}"',
         node.span);
   }
 
@@ skipping 260 matching lines @@
     // Then look for members in my library.
     member = home.library.lookup(name, span);
     if (member != null) {
       return member;
     }
 
     _ensureCode();
     return null;
   }
 }