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 44 matching lines @@
   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);
+
+bool _isBottom(TypeMirror t, {bool dynamicIsBottom: false}) {
+  if (t == _dynamicMirror && dynamicIsBottom) return true;
+  // TODO(vsm): We need direct support for non-nullability in DartType.
+  // This should check on "true/nonnullable" Bottom
+  if (t == _nullMirror && _typeOptions.nonnullableTypes.isEmpty) return true;

[Jennifer Messerly, 2015/04/01 19:12:46]

is this check needed? Normally isSubtype does not consider Null to be a subtype
of everything:

main() {
  print(null is String); // false
  print(null is Object); // true
  print(null is dynamic); // true
  print(null is Null); // true
}

... instead, it's just that null is explicitly allowed in "as" type cast:
this is also noted in the section on the `null` literal:
Also the _typeOptions.nonnullableTypes.isEmpty seems odd -- just because we add
one nonnullableType to the system, why does that change the behavior of Null
uniformly?

[vsm, 2015/04/01 21:04:04]

Yes, I'd been treating Null as bottom (as in the static types).  Updated.

+  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.
+  if (mirror is TypeVariableMirror) return false;

[Jennifer Messerly, 2015/04/01 19:12:46]

Does this happen at runtime?

$ cat test.dart
import 'dart:mirrors';

class Foo<B> {
  foo() {
    print(B);
    print(reflectType(B));
    print(reflectType(new List<B>().runtimeType).typeArguments);
  }
}

class Bar<Z> {
  bar() {
    new Foo<Z>().foo();
  }
}

main() => new Bar<int>().bar();

$ dart test.dart
int
ClassMirror on 'int'
[ClassMirror on 'int']


In other words, can I possibly do "is E" where E is a TypeVariable instead of a
substituted value? This seems like probably dead code.

[vsm, 2015/04/01 21:04:04]

I think you are right.  Changed this to an assert.

+
+  // 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;
   }
   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) {

[Jennifer Messerly, 2015/04/01 19:12:46]

similar question about TypeVariableMirror, do we actually get these?

[vsm, 2015/04/01 21:04:04]

I actually did hit this, in part because of how we canonicalize above.  The
above canonicalizes List<Object> to List.  Ideally, we'd canonicalize List to
List<Object>, but mirrors don't appear to let us construct the latter from the
former.

In JS, perhaps we should do it that way though.

+    t1 = t1.upperBound;
+  }
+
+  if (t2 is TypeVariableMirror) {
+    // TODO(vsm): Bottom?
+    t2 = _nullMirror;
+  }
+
   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) ||
+      _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;
+  }
+
+  // The null type is a subtype of any nonnullable type.
+  if (t1 == _nullMirror) {
+    // Return false iff t2 *may* be a primitive type.
+    return !isPrimitiveType(t2);
+  }
 
   // "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);
 }