Treat Object and dynamic similarly

lib/src/checker/rules.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.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 96 matching lines @@
     _nonnullableTypes.addAll(types.map(_typeFromName));
   }
 
   DartType getStaticType(Expression expr) {
     var type = expr.staticType;
     if (type != null) return type;
     _reporter.log(new MissingTypeError(expr));
     return provider.dynamicType;
   }
 
+  bool _isBottom(DartType t, {bool dynamicIsBottom: false}) {
+    if (t.isDynamic && dynamicIsBottom) return true;
+    // TODO(vsm): We need direct support for non-nullability in DartType.
+    // This should check on "true/nonnullable" Bottom
+    if (t.isBottom && _nonnullableTypes.isEmpty) return true;
+    return false;
+  }
+
+  bool _isTop(DartType t, {bool dynamicIsBottom: false}) {
+    if (t.isDynamic && !dynamicIsBottom) return true;
+    if (t.isObject) return true;
+    return false;
+  }
+
   bool isNonNullableType(DartType t) => _nonnullableTypes.contains(t);
 
   bool maybeNonNullableType(DartType t) {
     // Return true iff t *may* be a primitive type.
     // If t is a generic type parameter, return true if it may be
     // instantiated as a primitive.
     if (isNonNullableType(t)) {
       return true;
     } else if (t is TypeParameterType) {
       var bound = t.element.bound;
       if (bound == null) {
         bound = provider.dynamicType;
       }
       return _nonnullableTypes.any((DartType p) => isSubTypeOf(p, bound));
     } else {
       return false;
     }
   }
 
   bool _anyParameterType(FunctionType ft, bool predicate(DartType t)) {
     return ft.normalParameterTypes.any(predicate) ||
         ft.optionalParameterTypes.any(predicate) ||
         ft.namedParameterTypes.values.any(predicate);
   }
 
   // TODO(leafp): Revisit this.
   bool isGroundType(DartType t) {
     if (t is TypeParameterType) return false;
-    if (t.isDynamic) return true;
+    if (_isTop(t)) return true;
 
     if (t is FunctionType) {
-      if (!t.returnType.isDynamic ||
-          _anyParameterType(t, (pt) => !pt.isDynamic)) {
+      if (!_isTop(t.returnType) ||
+          _anyParameterType(t, (pt) => !_isBottom(pt, dynamicIsBottom: true))) {
         return false;
       } else {
         return true;
       }
     }
 
     if (t is InterfaceType) {
       var typeArguments = t.typeArguments;
       for (var typeArgument in typeArguments) {
-        if (!typeArgument.isDynamic && !typeArgument.isObject) return false;
+        if (!_isTop(typeArgument)) return false;
       }
       return true;
     }
 
     throw new StateError("Unexpected type");
   }
 
   FunctionType getCallMethodType(DartType t) {
     if (t is InterfaceType) {
       ClassElement element = t.element;
@@ skipping 102 matching lines @@
     for (final parent in i1.mixins) {
       if (_isInterfaceSubTypeOf(parent, i2)) return true;
     }
 
     return false;
   }
 
   bool isSubTypeOf(DartType t1, DartType t2, {bool dynamicIsBottom: false}) {
     if (t1 == t2) return true;
 
-    if (t2.isDynamic) return !dynamicIsBottom;
-    if (t1.isDynamic) return dynamicIsBottom;
+    // Trivially true.
+    if (_isTop(t2, dynamicIsBottom: dynamicIsBottom) ||
+        _isBottom(t1, dynamicIsBottom: dynamicIsBottom)) {
+      return true;
+    }
 
-    // Null can be assigned to anything non-primitive.
-    // FIXME: Can this be anything besides null?
+    // Trivially false.
+    if (_isTop(t1, dynamicIsBottom: dynamicIsBottom) ||
+        _isBottom(t2, dynamicIsBottom: dynamicIsBottom)) {
+      return false;
+    }
+
+    // The null type is a subtype of any nonnullable type.
+    // TODO(vsm): Note, t1.isBottom still allows for null confusingly.
+    // _isBottom(t1) does not necessarily imply t1.isBottom if there are
+    // nonnullable types in the system.
     if (t1.isBottom) {
       // Return false iff t2 *may* be a primitive type.
       return !maybeNonNullableType(t2);
     }
-    if (t2.isBottom) return false;
-
-    // Trivially true for non-primitives.
-    if (t2 == provider.objectType) return true;
-    if (t1 == provider.objectType) return false;
 
     // S <: T where S is a type variable
     //  T is not dynamic or object (handled above)
     //  S != T (handled above)
     //  So only true if bound of S is S' and
     //  S' <: T
     if (t1 is TypeParameterType) {
       DartType bound = t1.element.bound;
       if (bound == null) return false;
       return isSubTypeOf(bound, t2);
@@ skipping 218 matching lines @@
       if (element is FunctionElement || element is MethodElement) {
         // An original declaration.
         return false;
       }
     }
 
     var ft = t as FunctionType;
     return _anyParameterType(ft, (pt) => pt.isDynamic);
   }
 }