Enable is and as checks on non-ground types

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.
 
 var assert = chai.assert;
 var core = dart_library.import('dart/core');
 var collection = dart_library.import('dart/collection');
 var dart = dart_library.import('dart_runtime/dart');
 var dartx = dart.dartx;
 
@@ skipping 91 matching lines @@
 
 suite('instanceOf', () => {
   "use strict";
 
   let expect = assert.equal;
   let isGroundType = types.isGroundType;
   let generic = dart.generic;
   let intIsNonNullable = false;
   let cast = dart.as;
   let instanceOf = dart.is;
+  let strongInstanceOf = dart.strongInstanceOf;
   let runtimeType = dart.realRuntimeType;
   let functionType = dart.functionType;
   let typedef = dart.typedef;
   let isSubtype = types.isSubtype;
 
   let Object = core.Object;
   let String = core.String;
   let dynamic = dart.dynamic;
   let List = core.List;
   let Map = core.Map;
@@ skipping 61 matching lines @@
 
   let cls5 = dart.fn((a, o) => { return null; }, C, [A, Object]);
 
   let cls6 = dart.fn((b, s, o) => { return null; }, B, [B, String, String]);
 
   let cls7 = dart.fn((b, s, o) => { return null; }, B, [B, String], [Object]);
 
   let cls8 =
     dart.fn((b, s, o) => { return null; }, B, [B, String], {p: Object});
 
-  function checkType(x, type, expectedTrue) {
+  function checkType(x, type, expectedTrue, strongOnly) {
     if (expectedTrue === undefined) expectedTrue = true;
-    expect(instanceOf(x, type), expectedTrue);
+    if (strongOnly == undefined) strongOnly = false;
+    if (!strongOnly) {
+      expect(instanceOf(x, type), expectedTrue);
+    } else {
+      assert.throws(() => instanceOf(x, type), dart_utils.StrongModeError);
+      expect(strongInstanceOf(x, type), expectedTrue);
+    }
   }
 
   test('int', () => {
     expect(isGroundType(int), true);
     expect(isGroundType(runtimeType(5)), true);
 
     checkType(5, int);
     checkType(5, dynamic);
     checkType(5, Object);
     checkType(5, num);
@@ skipping 45 matching lines @@
 
     expect(cast(null, String), null);
   });
 
   test('Map', () => {
     let m1 = new (Map$(String, String))();
     let m2 = new (Map$(Object, Object))();
     let m3 = new Map();
     let m4 = new (collection.HashMap$(dart.dynamic, dart.dynamic))();
     let m5 = new collection.LinkedHashMap();
+    let m6 = new (Map$(String, dart.dynamic))();
+
 
     expect(isGroundType(Map), true);
     expect(isGroundType(runtimeType(m1)), false);
     expect(isGroundType(Map$(String, String)), false);
     expect(isGroundType(runtimeType(m2)), true);
     expect(isGroundType(Map$(Object, Object)), true);
     expect(isGroundType(runtimeType(m3)), true);
     expect(isGroundType(Map), true);
     expect(isGroundType(runtimeType(m4)), true);
     expect(isGroundType(collection.HashMap$(dynamic, dynamic)), true);
     expect(isGroundType(runtimeType(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, runtimeType(m1));
     checkType(m1, Map$(String, String));
 
     // Covariance on generics
     checkType(m1, runtimeType(m2));
     checkType(m1, Map$(Object, Object));
 
     // No contravariance on generics.
-    checkType(m2, runtimeType(m1), false);
-    checkType(m2, Map$(String, String), false);
+    checkType(m2, runtimeType(m1), false, true);
+    checkType(m2, Map$(String, String), false, true);
 
     // 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_utils.StrongModeError);
+    assert.throws(() => dart.is(m6, Map$(String, String)),
+      dart_utils.StrongModeError);
+    assert.isTrue(dart.is(m1, Map$(String, String)));
+    assert.throws(() => dart.is(m2, Map$(String, String)),
+      dart_utils.StrongModeError);
+
+    // As checks
+    // TODO(vsm): Enable these.  We're currently only logging warnings on
+    // StrongModeErrors.
+    // assert.throws(() => dart.as(m3, Map$(String, String)),
+    //   dart_utils.StrongModeError);
+    // assert.throws(() => dart.as(m6, Map$(String, String)),
+    //   dart_utils.StrongModeError);
+    assert.equal(dart.as(m1, Map$(String, String)), m1);
+    // assert.throws(() => dart.as(m2, Map$(String, String)),
+    //   dart_utils.StrongModeError);
   });
 
   test('constructors', () => {
     class C extends core.Object {
       C(x) {};
       named(x, y) {};
     }
     dart.defineNamedConstructor(C, 'named');
     dart.setSignature(C, {
       constructors: () => ({
@@ skipping 26 matching lines @@
     // This was AA<String> in Dart (wrong number of type args).
     let aabad = new (AA$(dart.dynamic, dart.dynamic))();
     let aabadtype = runtimeType(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, aatype, false, true);
+    checkType(cc, AA$(String, List), false, true);
     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(aa, bbtype, false, true);
+    checkType(aa, BB$(String, List), false, true);
     checkType(bb, cctype, false);
     checkType(bb, CC, false);
     checkType(aa, aabadtype);
     checkType(aa, dynamic);
-    checkType(aabad, aatype, false);
-    checkType(aabad, AA$(String, List), false);
+    checkType(aabad, aatype, false, true);
+    checkType(aabad, AA$(String, List), false, true);
     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);
   });
 
   test('void', () => {
     //checkType((x) => x, type((void _(x)) {}));
   });
 
   test('mixins', () => {
     let c = collection;
     var s1 = new (c.SplayTreeSet$(String))();
 
     checkType(s1, c.IterableMixin);
     checkType(s1, c.IterableMixin$(String));
-    checkType(s1, c.IterableMixin$(int), false);
+    checkType(s1, c.IterableMixin$(int), false, true);
 
     checkType(s1, c.SetMixin);
     checkType(s1, c.SetMixin$(String));
-    checkType(s1, c.SetMixin$(int), false);
+    checkType(s1, c.SetMixin$(int), false, true);
   });
 
   test('Type', () => {
     checkType(int, core.Type, true);
     checkType(num, core.Type, true);
     checkType(bool, core.Type, true);
     checkType(String, core.Type, true);
     checkType(dynamic, core.Type, true);
     checkType(Object, core.Type, true);
     checkType(List, core.Type, true);
     checkType(Map, core.Type, true);
     checkType(Map$(int, String), core.Type, true);
     checkType(Func2, core.Type, true);
     checkType(functionType(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(functionType(B, [B, String])), false);
-    checkType(bar1, Foo, false);
-    checkType(cls1, Foo, false);
-    checkType(bar1, functionType(B, [B, String]), false);
-    checkType(cls1, functionType(B, [B, String]), false);
-    checkType(bar2, Foo, false);
-    checkType(cls2, Foo, false);
-    checkType(bar2, functionType(B, [B, String]), false);
-    checkType(cls2, functionType(B, [B, String]), false);
+    checkType(bar1, Foo, false, true);
+    checkType(cls1, Foo, false, true);
+    checkType(bar1, functionType(B, [B, String]), false, true);
+    checkType(cls1, functionType(B, [B, String]), false, true);
+    checkType(bar2, Foo, false, true);
+    checkType(cls2, Foo, false, true);
+    checkType(bar2, functionType(B, [B, String]), false, true);
+    checkType(cls2, functionType(B, [B, String]), false, true);
     checkType(bar3, Foo);
     checkType(cls3, Foo);
     checkType(bar3, functionType(B, [B, String]));
     checkType(cls3, functionType(B, [B, String]));
     checkType(bar4, Foo, true);
     checkType(cls4, Foo, true);
     checkType(bar4, functionType(B, [B, String]), true);
     checkType(cls4, functionType(B, [B, String]), true);
     checkType(bar5, Foo);
     checkType(cls5, Foo);
     checkType(bar5, functionType(B, [B, String]));
     checkType(cls5, functionType(B, [B, String]));
-    checkType(bar6, Foo, false);
-    checkType(cls6, Foo, false);
-    checkType(bar6, functionType(B, [B, String]), false);
-    checkType(cls6, functionType(B, [B, String]), false);
+    checkType(bar6, Foo, false, true);
+    checkType(cls6, Foo, false, true);
+    checkType(bar6, functionType(B, [B, String]), false, true);
+    checkType(cls6, functionType(B, [B, String]), false, true);
     checkType(bar7, Foo);
     checkType(cls7, Foo);
     checkType(bar7, functionType(B, [B, String]));
     checkType(cls7, functionType(B, [B, String]));
     checkType(bar7, runtimeType(bar6));
     checkType(cls7, runtimeType(bar6));
     checkType(bar8, Foo);
     checkType(cls8, Foo);
     checkType(bar8, functionType(B, [B, String]));
     checkType(cls8, functionType(B, [B, String]));
-    checkType(bar8, runtimeType(bar6), false);
-    checkType(cls8, runtimeType(bar6), false);
-    checkType(bar7, runtimeType(bar8), false);
-    checkType(cls7, runtimeType(bar8), false);
-    checkType(bar8, runtimeType(bar7), false);
-    checkType(cls8, runtimeType(bar7), false);
+    checkType(bar8, runtimeType(bar6), false, true);
+    checkType(cls8, runtimeType(bar6), false, true);
+    checkType(bar7, runtimeType(bar8), false, true);
+    checkType(cls7, runtimeType(bar8), false, true);
+    checkType(bar8, runtimeType(bar7), false, true);
+    checkType(cls8, runtimeType(bar7), false, true);
 
     // Parameterized typedefs
     expect(isGroundType(FuncG), true);
     expect(isGroundType(FuncG$(B, String)), false);
-    checkType(bar1, FuncG$(B, String), false);
-    checkType(cls1, FuncG$(B, String), false);
+    checkType(bar1, FuncG$(B, String), false, true);
+    checkType(cls1, FuncG$(B, String), false, true);
     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, core.int, [core.int, core.int]);
     function ii_2i(x, y) {return x};
@@ skipping 114 matching lines @@
 
     // Optional types
     function ii_2i(x, y) {return x};
     dart.fn(ii_2i, core.int, [core.int], [core.int]);
     checkType(ii_2i, dart.functionType(core.int, [core.int],
                                        [core.int]));
     checkType(ii_2i, dart.functionType(core.int, [core.int,
                                                   core.int]));
     checkType(ii_2i, dart.functionType(core.int, [], [core.int,
                                                       core.int]),
-              false);
+              false, true);
     checkType(ii_2i, dart.functionType(core.int, [core.int],
-                                       {extra: core.int}), false);
+                                       {extra: core.int}), false, true);
 
     // Named types
     function i_i2i(x, opts) {return x};
     dart.fn(i_i2i, core.int, [core.int], {extra: core.int});
     checkType(i_i2i, dart.functionType(core.int, [core.int],
                                        {extra: core.int}));
     checkType(i_i2i, dart.functionType(core.int,
-                                       [core.int, core.int]), false);
+                                       [core.int, core.int]), false, true);
     checkType(i_i2i, dart.functionType(core.int, [core.int], {}));
     checkType(i_i2i,
         dart.functionType(core.int, [], {extra: core.int,
-                                         also: core.int}), false);
+                                         also: core.int}), false, true);
     checkType(i_i2i,
-        dart.functionType(core.int, [core.int], [core.int]), false);
+        dart.functionType(core.int, [core.int], [core.int]), false, true);
   });
 
   test('Method tearoffs', () => {
     let c = collection;
     // Tear off of an inherited method
     let map = new (Map$(core.int, core.String))();
     checkType(dart.bind(map, 'toString'),
         dart.functionType(String, []));
     checkType(dart.bind(map, 'toString'),
-        dart.functionType(int, []), false);
+        dart.functionType(int, []), false, true);
 
     // Tear off of a method directly on the object
     let smap = new (c.SplayTreeMap$(core.int, core.String))();
     checkType(dart.bind(smap, 'forEach'),
         dart.functionType(dart.void,
             [dart.functionType(dart.void, [core.int, core.String])]));
     checkType(dart.bind(smap, 'forEach'),
         dart.functionType(dart.void,
             [dart.functionType(dart.void,
-                [core.String, core.String])]), false);
+                [core.String, core.String])]), false, true);
 
     // Tear off of a mixed in method
     let mapB = new (c.MapBase$(core.int, core.int))();
     checkType(dart.bind(mapB, 'forEach'),
         dart.functionType(dart.void, [
             dart.functionType(dart.void, [core.int, core.int])]));
     checkType(dart.bind(mapB, 'forEach'),
         dart.functionType(dart.void, [
             dart.functionType(dart.void, [core.int, core.String])]),
-              false);
+              false, true);
 
     // Tear off of a method with a symbol name
     let listB = new (c.ListBase$(core.int))();
     checkType(dart.bind(listB, dartx.add),
               dart.functionType(dart.void, [core.int]));
     checkType(dart.bind(listB, dartx.add),
-              dart.functionType(dart.void, [core.String]), false);
+              dart.functionType(dart.void, [core.String]), false, true);
 
     // Tear off of a static method
     checkType(c.ListBase.listToString,
               dart.functionType(core.String, [core.List]));
     checkType(c.ListBase.listToString,
-              dart.functionType(core.String, [core.String]), false);
+              dart.functionType(core.String, [core.String]), false, true);
 
     // Tear off a mixin method
     class Base {
       m(x) {return x;}
     };
     dart.setSignature(Base, {
       methods: () => ({
         m: [core.int, [core.int]],
       })
     });
@@ skipping 16 matching lines @@
       })
     });
 
     class O extends dart.mixin(Base, M1, M2) {
       O() {};
     };
     dart.setSignature(O, {});
     var obj = new O();
     var m = dart.bind(obj, 'm');
     checkType(m, dart.functionType(core.Object, [core.int]));
-    checkType(m, dart.functionType(core.int, [core.int]), false);
+    checkType(m, dart.functionType(core.int, [core.int]), false, true);
 
     // Test inherited signatures
     class P extends O {
       P() {};
       m(x) {return x;};
     };
     dart.setSignature(P, {});
     var obj = new P();
     var m = dart.bind(obj, 'm');
     checkType(m, dart.functionType(core.Object, [core.int]));
-    checkType(m, dart.functionType(core.int, [core.int]), false);
+    checkType(m, dart.functionType(core.int, [core.int]), false, true);
   });
 
   test('Object members', () => {
     let nullHash = dart.hashCode(null);
     assert.equal(nullHash, 0);
     let nullString = dart.toString(null);
     assert.equal(nullString, 'null');
     let nullType = dart.runtimeType(null);
     assert.equal(nullType, core.Null);
 
@@ skipping 31 matching lines @@
 
 suite('primitives', function() {
   'use strict';
 
   test('fixed length list', () => {
     let list = new core.List(10);
     list[0] = 42;
     assert.throws(() => list.add(42));
   });
 });