Update dart_runtime.dart rules

lib/runtime/dart_runtime.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.
 
 library dev_compiler.runtime.dart_runtime;
 
 import 'dart:mirrors';
 
 import 'package:dev_compiler/config.dart';
 
@@ skipping 34 matching lines @@
   } else {
     // For non-null values, val is T => val as T succeeds.
     if (instanceOf(obj, staticType)) return obj;
   }
   // TODO(vsm): Add message.
   throw new CastError();
 }
 
 bool instanceOf(dynamic obj, Type staticType) {
   // This is our 'is' equivalent.
-  if (obj == null) {
-    // Only true for the Object type.
-    return staticType == Object || staticType == dynamic || staticType == Null;
-  }
-
   Type runtimeType = obj.runtimeType;
   return _isSubType(reflectType(runtimeType), reflectType(staticType));
 }
 
 bool isGroundType(Type type) {
-  // These are types allow in is / as expressions.
+  // These are types allowed in is / as expressions.
   final mirror = reflectType(type);
-  // Disallow functions.
-  if (mirror is FunctionTypeMirror) return false;
-  if (mirror is TypedefMirror) return false;
-  // Disallow generic type parameters.
-  if (mirror is TypeVariableMirror) return false;
-
-  if (mirror is ClassMirror) {
-    return _isRawClass(mirror);
-  }
-
-  // Only dynamic should be left.  Should this be allowed?
-  // It's not particularly useful.
-  assert(mirror.reflectedType == dynamic);
-  return true;
+  return _isGroundTypeMirror(mirror);
 }
 
 final _primitiveMap = {
   'int': int,
   'double': double,
   'num': num,
   'bool': bool,
   'String': String,
 };
 
@@ skipping 53 matching lines @@
 
   if (params1.length < params2.length) {
     return false;
   }
 
   for (int i = 0; i < params2.length; ++i) {
     ParameterMirror p1 = params1[i];
     ParameterMirror p2 = params2[i];
 
     // Contravariant parameter types.
-    if (!_isSubType(p2.type, p1.type)) {
+    if (!_isSubType(p2.type, p1.type, dynamicIsBottom: true)) {
       return false;
     }
 
     // Optional parameters.
     if (p2.isOptional) {
       // If the base param is optional, the sub param must be optional:
       if (!p1.isOptional) return false;
       if (!p2.isNamed) {
         // either neither are named or
         if (p1.isNamed) return false;
@@ skipping 19 matching lines @@
 bool _isClassSubType(ClassMirror m1, ClassMirror m2) {
   // TODO(vsm): Consider some caching for efficiency here.
 
   // We support Dart's covariant generics with the caveat that we do not
   // substitute bottom for dynamic in subtyping rules.
   // I.e., given T1, ..., Tn where at least one Ti != dynamic we disallow:
   // - S !<: S<T1, ..., Tn>
   // - S<dynamic, ..., dynamic> !<: S<T1, ..., Tn>
   if (m1 == m2) return true;
 
-  if (m1.hasReflectedType && m1.reflectedType == Object) return false;
+  if (_isTop(m1)) return false;
 
   // Check if m1 and m2 have the same raw type.  If so, check covariance on
   // type parameters.
   if (m1.originalDeclaration == m2.originalDeclaration) {
+    if (_isRawClass(m2)) return true;
+    if (_isRawClass(m1)) return false;
+
     final typeArguments1 = m1.typeArguments;
     final typeArguments2 = m2.typeArguments;
     final length = typeArguments1.length;
-    if (typeArguments2.length == 0) {
-      // m2 is the raw form of m1
-      return true;
-    } else if (typeArguments1.length == 0) {
-      // m1 is raw, but m2 is not
-      return false;
-    }
+    assert(typeArguments1.isNotEmpty && typeArguments2.isNotEmpty);
     assert(typeArguments2.length == length);
     for (var i = 0; i < length; ++i) {
       var typeArgument1 = typeArguments1[i];
       var typeArgument2 = typeArguments2[i];
       if (!_isSubType(typeArgument1, typeArgument2)) {
         return false;
       }
     }
     return true;
   }
 
   // Check superclass.
   if (_isClassSubType(m1.superclass, m2)) return true;
 
+  // Check for mixins.  The mixin getter returns the original class if there is
+  // no mixin.
+  if (m1 != m1.mixin && _isClassSubType(m1.mixin, m2)) return true;
+
   // Check interfaces.
   for (final parent in m1.superinterfaces) {
     if (_isClassSubType(parent, m2)) return true;
   }
 
   return false;
 }
 
+final _dynamicMirror = reflectType(dynamic);
+final _objectMirror = reflectType(Object);
+final _nullMirror = reflectType(Null);

[Jennifer Messerly, 2015/04/02 18:24:38]

fyi, I think this is unused now

[vsm, 2015/04/06 22:28:14]

removed

+
+bool _isBottom(TypeMirror t, {bool dynamicIsBottom: false}) {
+  if (t == _dynamicMirror && dynamicIsBottom) return true;
+  // TODO(vsm): Do we need an explicit representation of Bottom?
+  return false;
+}
+
+bool _isTop(TypeMirror t, {bool dynamicIsBottom: false}) {
+  if (t == _dynamicMirror && !dynamicIsBottom) return true;
+  if (t == _objectMirror) return true;
+  return false;
+}
+
+bool _isGroundTypeMirror(TypeMirror mirror) {
+  // Disallow generic type parameters.

[Leaf, 2015/04/03 00:34:02]

More like // type parameters shouldn't happen here?

[vsm, 2015/04/06 22:28:14]

Done.

+  assert(mirror is! TypeVariableMirror);
+
+  // Allow only 'raw' functions.
+  if (mirror is TypedefMirror) {
+    return _isRawFunction(mirror.referent);
+  }
+  if (mirror is FunctionTypeMirror) {
+    return _isRawFunction(mirror);
+  }
+
+  // Allow only 'raw' classes.
+  if (mirror is ClassMirror) {
+    return _isRawClass(mirror);
+  }
+
+  // Only dynamic should be left.  Should this be allowed?
+  // It's not particularly useful.
+  assert(mirror.reflectedType == dynamic);
+  return true;
+}
+
+bool _isRawFunction(FunctionTypeMirror mirror) {
+  var returnType = mirror.returnType;
+  if (!_isTop(returnType)) return false;
+  for (var parameter in mirror.parameters) {
+    var paramType = parameter.type;
+    if (!_isBottom(paramType, dynamicIsBottom: true)) return false;
+  }
+  return true;
+}
+
 bool _isRawClass(ClassMirror mirror) {
   // Allow only raw types.
   if (mirror == mirror.originalDeclaration) return true;
-  final dynamicMirror = reflectType(dynamic);
   for (var typeArgument in mirror.typeArguments) {
-    if (typeArgument != dynamicMirror) return false;
+    if (!_isTop(typeArgument)) return false;

[Leaf, 2015/04/03 00:34:02]

This treats List<Object> as a raw type.  This is maybe ok (at least for the
purpose of deciding whether to allow is checks) if we reify dynamic as Object? 
That is, we would always agree with normal dart on queries of the form (x is
List<dynamic>).  For queries of the form (x is List<Object>), we would would
disagree if x was reified as List<dynamic>, but if we rule that out on our side
by reifying x as List<Object>, then we will also accept.  So.. I think this is
ok for the specific uses we have in mind, but it's a little fragile.

[vsm, 2015/04/06 22:28:14]

Hmm, both:
- List<Object> <: List<dynamic>
- List<dynamic> <: List<Object>
are true in both Dart and our current static rules (which treat both as
List<Top>), so I'm not seeing disagreement regardless of whether we reify
List<dynamic>.

Note: dart:mirrors only allows us to create List from List<Object>, not the
other way around.  Otherwise, I think I'd prefer to map both to List<Object> for
clarity.

   }
   return true;
 }
 
 TypeMirror _canonicalizeTypeMirror(TypeMirror t) {
   if (t is TypedefMirror) {
     // We canonicalize Typedefs to their underlying function types.
     t = (t as TypedefMirror).referent;
   }
   if (t is ClassMirror && _isRawClass(t)) {
     // We canonicalize T<dynamic> to T.
     t = t.originalDeclaration;
   }
   return t;
 }
 
 bool _reflects(TypeMirror mirror, Type t) {
   return mirror.hasReflectedType && mirror.reflectedType == t;
 }
 
-bool _isSubType(TypeMirror t1, TypeMirror t2) {
+bool _isSubType(TypeMirror t1, TypeMirror t2, {bool dynamicIsBottom: false}) {
   t1 = _canonicalizeTypeMirror(t1);
   t2 = _canonicalizeTypeMirror(t2);
 
+  if (t1 is TypeVariableMirror) {
+    t1 = t1.upperBound;
+  }
+
   if (t1 == t2) return true;
 
-  // In Dart, dynamic is effectively both top and bottom.
-  // Here, we treat dynamic as top - the base type of everything.
-  if (_reflects(t1, dynamic)) return false;
-  if (_reflects(t2, dynamic)) return true;
+  // Trivially true.
+  if (_isTop(t2, dynamicIsBottom: dynamicIsBottom) ||

[Leaf, 2015/04/03 00:34:01]

I think this makes dynamic <: Object, which I think we can no longer allow given
the fuzzy type rule.

[vsm, 2015/04/06 22:28:14]

Hmm, I thought we added this with the new rule.  :-)

+      _isBottom(t1, dynamicIsBottom: dynamicIsBottom)) {
+    return true;
+  }
 
-  // Object only subtypes dynamic and Object.
-  if (_reflects(t2, Object)) return true;
-  if (_reflects(t1, Object)) return false;
+  // Trivially false.
+  if (_isTop(t1, dynamicIsBottom: dynamicIsBottom) ||
+      _isBottom(t2, dynamicIsBottom: dynamicIsBottom)) {
+    return false;
+  }
 
   // "Traditional" name-based subtype check.
   final c1 = t1 as ClassMirror;
   final c2 = t2 as ClassMirror;
   if (_isClassSubType(c1, c2)) {
     return true;
   }
 
   // Function subtyping.
   // Note: it appears under the hood all Dart functions map to a class / hidden type
@@ skipping 34 matching lines @@
     ret1 = call1.returnType;
     params1 = call1.parameters;
   }
 
   // Any type that implements a call method implicitly subtypes Function.
   if (_reflects(c2, Function)) return true;
 
   // Check structural function subtyping
   return _isFunctionSubType(ret1, params1, c2.returnType, c2.parameters);
 }