housecleaning: remove nonnullableTypes

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 14 matching lines @@
   bool isSubTypeOf(DartType t1, DartType t2);
   bool isAssignable(DartType t1, DartType t2);
 
   bool isGroundType(DartType t) => true;
   // TODO(vsm): The default implementation is not ignoring the return type,
   // only the restricted override is.
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
           {bool fuzzyArrows: true, bool ignoreReturn: false}) =>
       isSubTypeOf(f1, f2);
 
-  bool isNonNullableType(DartType t) => false;
-  bool maybeNonNullableType(DartType t) => false;
-
   StaticInfo checkAssignment(Expression expr, DartType t);
 
   DartType getStaticType(Expression expr) => expr.staticType;
 
   /// Given a type t, if t is an interface type with a call method
   /// defined, return the function type for the call method, otherwise
   /// return null.
   FunctionType getCallMethodType(DartType t) {
     if (t is InterfaceType) {
       ClassElement element = t.element;
@@ skipping 73 matching lines @@
       // Malformed type - fallback on analyzer error.
       return null;
     }
   }
 }
 
 typedef void MissingTypeReporter(Expression expr);
 
 class RestrictedRules extends TypeRules {
   final StrongModeOptions options;
-  final List<DartType> _nonnullableTypes;
   DownwardsInference inferrer;
 
-  DartType _typeFromName(String name) {
-    switch (name) {
-      case 'int':
-        return provider.intType;
-      case 'double':
-        return provider.doubleType;
-      case 'num':
-        return provider.numType;
-      case 'bool':
-        return provider.boolType;
-      case 'String':
-        return provider.stringType;
-      default:
-        throw new UnsupportedError('Unsupported non-nullable type $name');
-    }
-  }
-
-  RestrictedRules(TypeProvider provider, {this.options})
-      : _nonnullableTypes = <DartType>[],
-        super(provider) {
-    var types = options.nonnullableTypes;
-    _nonnullableTypes.addAll(types.map(_typeFromName));
+  RestrictedRules(TypeProvider provider, {this.options}) : super(provider) {
     inferrer = new DownwardsInference(this);
   }
 
   DartType getStaticType(Expression expr) {
     var type = expr.staticType;
     if (type != null) return type;
     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;
+    if (t.isBottom) 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 (_isTop(t)) return true;
@@ skipping 132 matching lines @@
         _isBottom(t1, dynamicIsBottom: dynamicIsBottom)) {
       return true;
     }
 
     // Trivially false.
     if (_isTop(t1, dynamicIsBottom: dynamicIsBottom) ||
         _isBottom(t2, dynamicIsBottom: dynamicIsBottom)) {
       return false;
     }
 
-    // The null type is a subtype of any nonnullable type.

[vsm, 2015/10/09 15:29:38]

doh!

+    // The null type is a subtype of any nullable type, which is all Dart types.
     // 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);
+      return true;
     }
 
     // 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;
@@ skipping 430 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }