Update dart_runtime.dart rules

test/runtime/dart_runtime_test.dart

 // 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.
 
 // Test code
 import 'dart:collection';
 import 'dart:mirrors';
 import 'package:unittest/unittest.dart';
 import 'package:dev_compiler/config.dart';
 import 'package:dev_compiler/runtime/dart_runtime.dart';
@@ skipping 17 matching lines @@
   T x;
   U y;
 }
 
 class BB<T, U> extends AA<U, T> {
   T z;
 }
 
 class CC extends BB<String, List> {}
 
+typedef Func2(x, y);
 typedef B Foo(B b, String s);
 
 A bar1(C c, String s) => null;
 bar2(B b, String s) => null;
 B bar3(B b, Object o) => null;
 B bar4(B b, o) => null;
 C bar5(A a, Object o) => null;
 B bar6(B b, String s, String o) => null;
 B bar7(B b, String s, [Object o]) => null;
 B bar8(B b, String s, {Object p}) => null;
@@ skipping 83 matching lines @@
   test('Map', () {
     final m1 = new Map<String, String>();
     final m2 = new Map<Object, Object>();
     final m3 = new Map();
     final m4 = new HashMap<dynamic, dynamic>();
     final m5 = new LinkedHashMap();
 
     expect(isGroundType(Map), isTrue);
     expect(isGroundType(m1.runtimeType), isFalse);
     expect(isGroundType(type((Map<String, String> _) {})), isFalse);
-    expect(isGroundType(m2.runtimeType), isFalse);
-    expect(isGroundType(type((Map<Object, Object> _) {})), isFalse);
+    expect(isGroundType(m2.runtimeType), isTrue);
+    expect(isGroundType(type((Map<Object, Object> _) {})), isTrue);
     expect(isGroundType(m3.runtimeType), isTrue);
     expect(isGroundType(type((Map _) {})), isTrue);
     expect(isGroundType(m4.runtimeType), isTrue);
     expect(isGroundType(type((HashMap<dynamic, dynamic> _) {})), isTrue);
     expect(isGroundType(m5.runtimeType), isTrue);
     expect(isGroundType(type((LinkedHashMap _) {})), isTrue);
     expect(isGroundType(LinkedHashMap), isTrue);
 
     // Map<T1,T2> <: Map
     checkType(m1, Map);
     checkType(m1, Object);
 
     // Instance of self
     checkType(m1, m1.runtimeType);
     checkType(m1, type((Map<String, String> _) {}));
 
+    // Object == dynamic == top as a type parameter
+    checkType(m2, m3.runtimeType);
+    checkType(m2, Map);
+    checkType(m3, m2.runtimeType);
+    checkType(m3, type((Map<Object, Object> _) {}));
+
     // Covariance on generics
     checkType(m1, m2.runtimeType);
     checkType(m1, type((Map<Object, Object> _) {}));
 
     // No contravariance on generics.
     checkType(m2, m1.runtimeType, false);
     checkType(m2, type((Map<String, String> _) {}), false);
 
     // null is! Map
     checkType(null, Map, false);
 
     // Raw generic types
     checkType(m5, Map);
+    checkType(m5, type((Map<Object, Object> _) {}));
     checkType(m4, Map);
+    checkType(m4, type((Map<Object, Object> _) {}));
+
+    // Mixin: the actual implementation class should implement MapMixin
+    checkType(m1, MapMixin);
+    checkType(m1, type((MapMixin<String, String> _) {}));
+    checkType(m1, type((MapMixin<Object, Object> _) {}));
+    checkType(m5, MapMixin);
+    checkType(m5, type((MapMixin<String, String> _) {}), false);
+    checkType(m5, type((MapMixin<Object, Object> _) {}));
   });
 
   test('generic and inheritance', () {
     AA aaraw = new AA();
     final aarawtype = aaraw.runtimeType;
     AA<dynamic, dynamic> aadynamic = new AA<dynamic, dynamic>();
     final aadynamictype = aadynamic.runtimeType;
     AA<String, List> aa = new AA<String, List>();
     final aatype = aa.runtimeType;
     BB<String, List> bb = new BB<String, List>();
@@ skipping 29 matching lines @@
     checkType(aaraw, type((AA<String> _) {}));
     checkType(aaraw, aadynamictype);
     checkType(aaraw, type((AA<dynamic, dynamic> _) {}));
     checkType(aadynamic, aarawtype);
     checkType(aadynamic, AA);
   });
 
   test('Functions', () {
     // - return type: Dart is bivariant.  We're covariant.
     // - param types: Dart is bivariant.  We're contravariant.
+    expect(isGroundType(Func2), isTrue);
     expect(isGroundType(Foo), isFalse);
     expect(isGroundType(type((B _(B _1, String _2)) {})), isFalse);
     checkType(bar1, Foo, false);
     checkType(bar1, type((B _(B _1, String _2)) {}), false);
     checkType(bar2, Foo, false);
     checkType(bar2, type((B _(B _1, String _2)) {}), false);
     checkType(bar3, Foo);
     checkType(bar3, type((B _(B _1, String _2)) {}));
-    checkType(bar4, Foo);
-    checkType(bar4, type((B _(B _1, String _2)) {}));
+    checkType(bar4, Foo, false);
+    // TODO(vsm): Revisit.  bar4 is (B, *) -> B.  Perhaps it should be treated as top for a reified object.
+    checkType(bar4, type((B _(B _1, String _2)) {}), false);
     checkType(bar5, Foo);
     checkType(bar5, type((B _(B _1, String _2)) {}));
     checkType(bar6, Foo, false);
     checkType(bar6, type((B _(B _1, String _2)) {}), false);
     checkType(bar7, Foo);
     checkType(bar7, type((B _(B _1, String _2)) {}));
     checkType(bar7, bar6.runtimeType);
     checkType(bar8, Foo);
     checkType(bar8, type((B _(B _1, String _2)) {}));
     checkType(bar8, bar6.runtimeType, false);
@@ skipping 24 matching lines @@
   test('arity', () {
     checkArity(bar1, 2, 2);
     checkArity(bar4, 2, 2);
     checkArity(bar6, 3, 3);
     checkArity(bar7, 2, 3);
     checkArity(bar8, 2, 2);
     checkArity(() {}, 0, 0);
     checkArity((a, [b]) {}, 1, 2);
   });
 }