fix #28988, remove throw on Dart1 incompatible is-checks for dartdevc

pkg/dev_compiler/test/browser/runtime_tests.js

 // Copyright (c) 2015, 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.
 
 define(['dart_sdk'], function(dart_sdk) {
   const assert = chai.assert;
   const async = dart_sdk.async;
   const core = dart_sdk.core;
   const collection = dart_sdk.collection;
   const dart = dart_sdk.dart;
@@ skipping 125 matching lines @@
       let l = dart_sdk._interceptors.JSArray$(core.int).of([1, 2, 3]);
       let s = l[dartx.join]();
       assert.equal(s, '123');
     });
   });
 
 
   suite('instanceOf', () => {
     "use strict";
 
-    setup(() => {
-      dart_sdk.dart.failForWeakModeIsChecks(true);
-    });
-
-    teardown(() => {
-      dart_sdk.dart.failForWeakModeIsChecks(false);
-    });
-
     let expect = assert.equal;
-    let isGroundType = dart.isGroundType;
     let generic = dart.generic;
     let intIsNonNullable = false;
     let cast = dart.as;
     let instanceOf = dart.is;
     let strongInstanceOf = dart.strongInstanceOf;
     let getReifiedType = dart.getReifiedType;
     let fnTypeFuzzy = dart.fnTypeFuzzy;
     let typedef = dart.typedef;
     let isSubtype = dart.isSubtype;
 
@@ skipping 84 matching lines @@
     let cls6 = dart.fn((b, s, o) => { return null; },
                        dart.fnType(B, [B, String, String]));
 
     let cls7 = dart.fn((b, s, o) => { return null; },
                        dart.fnType(B, [B, String], [Object]));
 
     let cls8 =
       dart.fn((b, s, o) => { return null; },
               dart.fnType(B, [B, String], {p: Object}));
 
     function checkType(x, type, expectedTrue, strongOnly) {

[Leaf, 2017/08/05 02:24:27]

Is strongOnly dead now?

[Jennifer Messerly, 2017/08/07 23:30:53]

Done.

       if (expectedTrue === undefined) expectedTrue = true;
-      if (strongOnly === undefined) strongOnly = false;
-      if (!strongOnly) {
-        assert.doesNotThrow(() => instanceOf(x, type));
-        expect(instanceOf(x, type), expectedTrue,
-          '"' + x + '" ' +
-          (expectedTrue ? 'should' : 'should not') +
-          ' be an instance of "' + dart.typeName(type) + '"');
-      } else {
-        assert.throws(() => instanceOf(x, type), dart.StrongModeError);
-        expect(expectedTrue, false);
-        expect(strongInstanceOf(x, type), null);
-      }
+      expect(instanceOf(x, type), expectedTrue,
+        '"' + x + '" ' +
+        (expectedTrue ? 'should' : 'should not') +
+        ' be an instance of "' + dart.typeName(type) + '"');
     }
 
     test('int', () => {
-      expect(isGroundType(int), true);
-      expect(isGroundType(getReifiedType(5)), true);
-
       checkType(5, int);
       checkType(5, dynamic);
       checkType(5, Object);
       checkType(5, num);
 
       checkType(5, bool, false);
       checkType(5, String, false);
 
       expect(cast(5, int), 5);
       if (intIsNonNullable) {
         expect(() => cast(null, int), throws);
       } else {
         expect(cast(null, int), null);
       }
     });
 
     test('dynamic', () => {
-      expect(isGroundType(dynamic), true);
       checkType(new Object.new(), dynamic);
       checkType(null, dynamic);
 
       expect(cast(null, dynamic), null);
     });
 
     test('Object', () => {
-      expect(isGroundType(Object), true);
       checkType(new Object.new(), dynamic);
       checkType(null, Object);
 
       expect(cast(null, Object), null);
     });
 
     test('null', () => {
       // Object, dynamic cases are already handled above.
       checkType(null, core.Null);
       checkType(null, core.String, false);
       checkType(null, core.int, false);
       checkType(null, Map, false);
       checkType(void 0, core.Null);
       checkType(void 0, core.Object);
       checkType(void 0, dart.dynamic);
     });
 
     test('String', () => {
-      expect(isGroundType(String), true);
-      expect(isGroundType(getReifiedType("foo")), true);
       checkType("foo", String);
       checkType("foo", Object);
       checkType("foo", dynamic);
 
       expect(cast(null, String), null);
     });
 
     test('FutureOr', () => {
       let FutureOr = async.FutureOr$;
 
@@ skipping 12 matching lines @@
     });
 
     test('Map', () => {
       let m1 = Map$(String, String).new();
       let m2 = Map$(Object, Object).new();
       let m3 = Map.new();
       let m4 = collection.HashMap$(dart.dynamic, dart.dynamic).new();
       let m5 = collection.LinkedHashMap.new();
       let m6 = Map$(String, dart.dynamic).new();
 
-      expect(isGroundType(Map), true);
-      expect(isGroundType(getReifiedType(m1)), false);
-      expect(isGroundType(Map$(String, String)), false);
-      expect(isGroundType(getReifiedType(m2)), true);
-      expect(isGroundType(Map$(Object, Object)), true);
-      expect(isGroundType(getReifiedType(m3)), true);
-      expect(isGroundType(Map), true);
-      expect(isGroundType(getReifiedType(m4)), true);
-      expect(isGroundType(collection.HashMap$(dynamic, dynamic)), true);
-      expect(isGroundType(getReifiedType(m5)), true);
-      expect(isGroundType(collection.LinkedHashMap), true);
-      expect(isGroundType(collection.LinkedHashMap), true);
-
       // Map<T1,T2> <: Map
       checkType(m1, Map);
       checkType(m1, Object);
 
       // Instance of self
       checkType(m1, getReifiedType(m1));
       checkType(m1, Map$(String, String));
 
       // Covariance on generics
       checkType(m1, getReifiedType(m2));
       checkType(m1, Map$(Object, Object));
 
       // No contravariance on generics.
       checkType(m2, getReifiedType(m1), false);
       checkType(m2, Map$(String, String), false);
 
       // null is! Map
       checkType(null, Map, false);
 
       // Raw generic types
       checkType(m5, Map);
       checkType(m4, Map);
 
       // Is checks
-      assert.throws(() => dart.is(m3, Map$(String, String)),
-        dart.StrongModeError);
-      assert.throws(() => dart.is(m6, Map$(String, String)),
-        dart.StrongModeError);
+      assert.isFalse(dart.is(m3, Map$(String, String)));
+      assert.isFalse(dart.is(m6, Map$(String, String)));
       assert.isTrue(dart.is(m1, Map$(String, String)));
       assert.isFalse(dart.is(m2, Map$(String, String)));
 
       // As checks
       // TODO(vsm): Enable these.  We're currently only logging warnings on
       // StrongModeErrors.
       // assert.throws(() => dart.as(m3, Map$(String, String)),
       //   dart.StrongModeError);
       // assert.throws(() => dart.as(m6, Map$(String, String)),
       //   dart.StrongModeError);
@@ skipping 32 matching lines @@
       let aatype = getReifiedType(aa);
       let bb = new (BB$(String, List).new)();
       let bbtype = getReifiedType(bb);
       let cc = new CC.new();
       let cctype = getReifiedType(cc);
       // We don't allow constructing bad types.
       // This was AA<String> in Dart (wrong number of type args).
       let aabad = new (AA$(dart.dynamic, dart.dynamic).new)();
       let aabadtype = getReifiedType(aabad);
 
-      expect(isGroundType(aatype), false);
-      expect(isGroundType(AA$(String, List)), false);
-      expect(isGroundType(bbtype), false);
-      expect(isGroundType(BB$(String, List)), false);
-      expect(isGroundType(cctype), true);
-      expect(isGroundType(CC), true);
       checkType(cc, aatype, false);
       checkType(cc, AA$(String, List), false);
       checkType(cc, bbtype);
       checkType(cc, BB$(String, List));
       checkType(aa, cctype, false);
       checkType(aa, CC, false);
       checkType(aa, bbtype, false);
       checkType(aa, BB$(String, List), false);
       checkType(bb, cctype, false);
       checkType(bb, CC, false);
       checkType(aa, aabadtype);
       checkType(aa, dynamic);
-      checkType(aabad, aatype, false, true);
-      checkType(aabad, AA$(String, List), false, true);
+      checkType(aabad, aatype, false);
+      checkType(aabad, AA$(String, List), false);
       checkType(aabad, aarawtype);
       checkType(aabad, AA);
       checkType(aaraw, aabadtype);
       checkType(aaraw, AA$(dart.dynamic, dart.dynamic));
       checkType(aaraw, aadynamictype);
       checkType(aaraw, AA$(dynamic, dynamic));
       checkType(aadynamic, aarawtype);
       checkType(aadynamic, AA);
     });
 
@@ skipping 28 matching lines @@
       checkType(fnTypeFuzzy(dynamic, [dynamic]), core.Type, true);
       checkType(core.Type, core.Type, true);
 
       checkType(3, core.Type, false);
       checkType("hello", core.Type, false);
     })
 
     test('Functions', () => {
       // - return type: Dart is bivariant.  We're covariant.
       // - param types: Dart is bivariant.  We're contravariant.
-      expect(isGroundType(Func2), true);
-      expect(isGroundType(Foo), false);
-      expect(isGroundType(fnTypeFuzzy(B, [B, String])), false);
-      checkType(bar1, Foo, false, true);
-      checkType(cls1, Foo, false, true);
-      checkType(bar1, fnTypeFuzzy(B, [B, String]), false, true);
-      checkType(cls1, fnTypeFuzzy(B, [B, String]), false, true);
-      checkType(bar2, Foo, false, true);
-      checkType(cls2, Foo, false, true);
-      checkType(bar2, fnTypeFuzzy(B, [B, String]), false, true);
-      checkType(cls2, fnTypeFuzzy(B, [B, String]), false, true);
+      checkType(bar1, Foo, false);
+      checkType(cls1, Foo, false);
+      checkType(bar1, fnTypeFuzzy(B, [B, String]), false);
+      checkType(cls1, fnTypeFuzzy(B, [B, String]), false);
+      checkType(bar2, Foo, false);
+      checkType(cls2, Foo, false);
+      checkType(bar2, fnTypeFuzzy(B, [B, String]), false);
+      checkType(cls2, fnTypeFuzzy(B, [B, String]), false);
       checkType(bar3, Foo);
       checkType(cls3, Foo);
       checkType(bar3, fnTypeFuzzy(B, [B, String]));
       checkType(cls3, fnTypeFuzzy(B, [B, String]));
       checkType(bar4, Foo, true);
       checkType(cls4, Foo, true);
       checkType(bar4, fnTypeFuzzy(B, [B, String]), true);
       checkType(cls4, fnTypeFuzzy(B, [B, String]), true);
       checkType(bar5, Foo);
       checkType(cls5, Foo);
@@ skipping 14 matching lines @@
       checkType(bar8, fnTypeFuzzy(B, [B, String]));
       checkType(cls8, fnTypeFuzzy(B, [B, String]));
       checkType(bar8, getReifiedType(bar6), false);
       checkType(cls8, getReifiedType(bar6), false);
       checkType(bar7, getReifiedType(bar8), false);
       checkType(cls7, getReifiedType(bar8), false);
       checkType(bar8, getReifiedType(bar7), false);
       checkType(cls8, getReifiedType(bar7), false);
 
       // Parameterized typedefs
-      expect(isGroundType(FuncG), true);
-      expect(isGroundType(FuncG$(B, String)), false);
-      checkType(bar1, FuncG$(B, String), false, true);
-      checkType(cls1, FuncG$(B, String), false, true);
+      checkType(bar1, FuncG$(B, String), false);
+      checkType(cls1, FuncG$(B, String), false);
       checkType(bar3, FuncG$(B, String));
       checkType(cls3, FuncG$(B, String));
     });
 
     test('dcall', () => {
       function dd2d(x, y) {return x};
       dart.fn(dd2d);
       function ii2i(x, y) {return x};
       dart.fn(ii2i, dart.fnType(core.int, [core.int, core.int]));
       function ii_2i(x, y) {return x};
@@ skipping 223 matching lines @@
           m: dart.fnType(core.Object, [core.int]),
         })
       });
 
       class O extends dart.mixin(Base, M1, M2) {}
       (O.new = function() {}).prototype = O.prototype;
       dart.setSignature(O, {});
       var obj = new O.new();
       var m = dart.bind(obj, 'm');
       checkType(m, dart.fnTypeFuzzy(core.Object, [core.int]));
-      checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false, true);
+      checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false);
 
       // Test inherited signatures
       class P extends O {
         m(x) {return x;};
       };
       (P.new = function() {}).prototype = P.prototype;
       dart.setSignature(P, {});
       var obj = new P.new();
       var m = dart.bind(obj, 'm');
       checkType(m, dart.fnTypeFuzzy(core.Object, [core.int]));
-      checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false, true);
+      checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false);
     });
 
     test('Object members', () => {
       let nullHash = dart.hashCode(null);
       assert.equal(nullHash, 0);
       let nullString = dart.toString(null);
       assert.equal(nullString, 'null');
 
       let map = Map.new();
       let mapHash = dart.hashCode(map);
@@ skipping 459 matching lines @@
       list[0] = 42;
       assert.throws(() => list.add(42));
     });
 
     test('toString on ES Symbol', () => {
       let sym = Symbol('_foobar');
       assert.equal(dart.toString(sym), 'Symbol(_foobar)');
     });
   });
 });