Only use white list on indefinite checks

BUG=
[email protected]

Review URL: https://codereview.chromium.org/1953823005 .

Author: leafpetersen

pkg/dev_compiler/lib/runtime/dart_sdk.js

@@ -531,6 +531,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     let actual = dart.getReifiedType(obj);
     let result = dart.isSubtype(actual, type);
     if (result || actual == dart.jsobject || actual == core.int && type == core.double) return true;
+    if (result === false) return false;
     if (ignoreFromWhiteList == void 0) return result;
     if (dart._ignoreTypeFailure(actual, type)) return true;
     return result;
@@ -13395,9 +13396,9 @@ dart_library.library('dart_sdk', null, /* Imports */[
   async._registerErrorHandler = function(R) {
     return (errorHandler, zone) => {
       if (dart.is(errorHandler, async.ZoneBinaryCallback)) {
-        return zone.registerBinaryCallback(R, dart.dynamic, core.StackTrace)(dart.as(errorHandler, async.ZoneBinaryCallback$(R, dart.dynamic, core.StackTrace)));
+        return zone.registerBinaryCallback(dart.dynamic, dart.dynamic, core.StackTrace)(dart.as(errorHandler, async.ZoneBinaryCallback$(dart.dynamic, dart.dynamic, core.StackTrace)));
       } else {
-        return zone.registerUnaryCallback(R, dart.dynamic)(dart.as(errorHandler, async.ZoneUnaryCallback$(R, dart.dynamic)));
+        return zone.registerUnaryCallback(dart.dynamic, dart.dynamic)(dart.as(errorHandler, async.ZoneUnaryCallback));
       }
     };
   };

pkg/dev_compiler/test/codegen/lib/typed_data/typed_data_list_test.dart

@@ -9,7 +9,7 @@ import 'package:expect/expect.dart';
 @NoInline()
 confuse(x) => x;
 
-void testListFunctions(list, first, last, toElementType) {
+void testListFunctions/*<T>*/(list, first, last, /*=T*/ toElementType(dynamic x)) {
   assert(list.length > 0);
 
   var reversed = list.reversed;
@@ -20,16 +20,21 @@ void testListFunctions(list, first, last, toElementType) {
     index--;
   }
 
+  var zero = toElementType(0);
+  var one = toElementType(1);
+  var two = toElementType(2);
   // Typed lists are fixed length.
-  Expect.throws(() => list.add(0), (e) => e is UnsupportedError);
-  Expect.throws(() => list.addAll([1, 2]), (e) => e is UnsupportedError);
+  Expect.throws(() => list.add(zero), (e) => e is UnsupportedError);
+  Expect.throws(() => list.addAll([one, two]), (e) => e is UnsupportedError);
   Expect.throws(() => list.clear(), (e) => e is UnsupportedError);
-  Expect.throws(() => list.insert(0, 0), (e) => e is UnsupportedError);
-  Expect.throws(() => list.insertAll(0, [1, 2]), (e) => e is UnsupportedError);
-  Expect.throws(() => list.remove(0), (e) => e is UnsupportedError);
+  Expect.throws(() => list.insert(0, zero), (e) => e is UnsupportedError);
+  Expect.throws(() => list.insertAll(0, [one, two]),
+                (e) => e is UnsupportedError);
+  Expect.throws(() => list.remove(zero), (e) => e is UnsupportedError);
   Expect.throws(() => list.removeAt(0), (e) => e is UnsupportedError);
   Expect.throws(() => list.removeLast(), (e) => e is UnsupportedError);
-  Expect.throws(() => list.removeRange(0, 1), (e) => e is UnsupportedError);
+  Expect.throws(() => list.removeRange(0, 1),
+                (e) => e is UnsupportedError);
   Expect.throws(() => list.removeWhere((x) => true),
                 (e) => e is UnsupportedError);
   Expect.throws(() => list.replaceRange(0, 1, []),
@@ -123,21 +128,24 @@ void testListFunctions(list, first, last, toElementType) {
       (e) => e is RangeError);
 }
 
-void emptyChecks(list) {
+void emptyChecks/*<T>*/(list, /*=T*/ toElementType(dynamic c)) {
   assert(list.length == 0);
 
   Expect.isTrue(list.isEmpty);
 
   var reversed = list.reversed;
   Expect.listEquals(list, reversed.toList().reversed.toList());
 
+  var zero = toElementType(0);
+  var one = toElementType(1);
+  var two = toElementType(2);
   // Typed lists are fixed length. Even when they are empty.
-  Expect.throws(() => list.add(0), (e) => e is UnsupportedError);
-  Expect.throws(() => list.addAll([1, 2]), (e) => e is UnsupportedError);
+  Expect.throws(() => list.add(zero), (e) => e is UnsupportedError);
+  Expect.throws(() => list.addAll([one, two]), (e) => e is UnsupportedError);
   Expect.throws(() => list.clear(), (e) => e is UnsupportedError);
-  Expect.throws(() => list.insert(0, 0), (e) => e is UnsupportedError);
-  Expect.throws(() => list.insertAll(0, [1, 2]), (e) => e is UnsupportedError);
-  Expect.throws(() => list.remove(0), (e) => e is UnsupportedError);
+  Expect.throws(() => list.insert(0, zero), (e) => e is UnsupportedError);
+  Expect.throws(() => list.insertAll(0, [one, two]), (e) => e is UnsupportedError);
+  Expect.throws(() => list.remove(zero), (e) => e is UnsupportedError);
   Expect.throws(() => list.removeAt(0), (e) => e is UnsupportedError);
   Expect.throws(() => list.removeLast(), (e) => e is UnsupportedError);
   Expect.throws(() => list.removeRange(0, 1), (e) => e is UnsupportedError);
@@ -174,8 +182,8 @@ void emptyChecks(list) {
 }
 
 main() {
-  toDouble(x) => x.toDouble();
-  toInt(x) => x.toInt();
+  double toDouble(x) => x.toDouble();
+  int toInt(x) => x.toInt();
 
   testListFunctions(new Float32List.fromList([1.5, 6.3, 9.5]),
                     1.5, 9.5, toDouble);
@@ -188,12 +196,12 @@ main() {
   testListFunctions(new Uint16List.fromList([3, 5, 9]), 3, 9, toInt);
   testListFunctions(new Uint32List.fromList([3, 5, 9]), 3, 9, toInt);
 
-  emptyChecks(new Float32List(0));
-  emptyChecks(new Float64List(0));
-  emptyChecks(new Int8List(0));
-  emptyChecks(new Int16List(0));
-  emptyChecks(new Int32List(0));
-  emptyChecks(new Uint8List(0));
-  emptyChecks(new Uint16List(0));
-  emptyChecks(new Uint32List(0));
+  emptyChecks(new Float32List(0), toDouble);
+  emptyChecks(new Float64List(0), toDouble);
+  emptyChecks(new Int8List(0), toInt);
+  emptyChecks(new Int16List(0), toInt);
+  emptyChecks(new Int32List(0), toInt);
+  emptyChecks(new Uint8List(0), toInt);
+  emptyChecks(new Uint16List(0), toInt);
+  emptyChecks(new Uint32List(0), toInt);
 }

pkg/dev_compiler/tool/input_sdk/lib/async/async_error.dart

@@ -16,11 +16,21 @@ _invokeErrorHandler(Function errorHandler,
 
 Function _registerErrorHandler/*<R>*/(Function errorHandler, Zone zone) {
   if (errorHandler is ZoneBinaryCallback) {
-    return zone.registerBinaryCallback/*<R, dynamic, StackTrace>*/(
-        errorHandler as dynamic/*=ZoneBinaryCallback<R, dynamic, StackTrace>*/);
+    // TODO(leafp): These are commented out, because the async libraries
+    // pass a (...) -> void into this function which fails whenever R
+    // is something interesting.  This needs to be sorted out in the main
+    // SDK as to what the intent is here: if this is really supposed to
+    // return an R, then the function that gets passed in is wrong.  If not,
+    // then this code doesn't need to track the return type at all.
+    //    return zone.registerBinaryCallback/*<R, dynamic, StackTrace>*/(
+    //        errorHandler as dynamic/*=ZoneBinaryCallback<R, dynamic, StackTrace>*/);
+    return zone.registerBinaryCallback/*<dynamic, dynamic, StackTrace>*/(
+        errorHandler as dynamic/*=ZoneBinaryCallback<dynamic, dynamic, StackTrace>*/);
   } else {
-    return zone.registerUnaryCallback/*<R, dynamic>*/(
-        errorHandler as dynamic/*=ZoneUnaryCallback<R, dynamic>*/);
+    //    return zone.registerUnaryCallback/*<R, dynamic>*/(
+    //        errorHandler as dynamic/*=ZoneUnaryCallback<R, dynamic>*/);
+    return zone.registerUnaryCallback/*<dynamic, dynamic>*/(
+        errorHandler as dynamic/*=ZoneUnaryCallback<dynamic, dynamic>*/);
   }
 }
 

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart

@@ -204,6 +204,7 @@ strongInstanceOf(obj, type, ignoreFromWhiteList) => JS('', '''(() => {
   let result = $isSubtype(actual, $type);
   if (result || actual == $jsobject ||
       actual == $int && type == $double) return true;
+  if (result === false) return false;
   if ($ignoreFromWhiteList == void 0) return result;
   if ($_ignoreTypeFailure(actual, $type)) return true;
   return result;