housecleaning: remove nonnullableTypes

lib/src/codegen/js_codegen.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.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 307 matching lines @@
     // Skip the cast if it's not needed.
     if (rules.isSubTypeOf(from, to)) return fromExpr;
 
     // All Dart number types map to a JS double.
     if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
       if (from != _types.intType && to == _types.intType) {
         return js.call('dart.asInt(#)', [fromExpr]);
       }
 
-      if (!rules.isNonNullableType(from) && rules.isNonNullableType(to)) {
-        // Converting from a nullable number to a non-nullable number
-        // only requires a null check.
-        // TODO(jmesserly): a lot of these checks are meaningless, as people use
-        // `num` to mean "any kind of number" rather than "could be null".
-        // The core libraries especially suffer from this problem, with many of
-        // the `num` methods returning `num`.
-        return js.call('dart.notNull(#)', fromExpr);
-      } else {
-        // A no-op in JavaScript.
-        return fromExpr;
-      }
+      // A no-op in JavaScript.
+      return fromExpr;
     }
 
     return js.call('dart.as(#, #)', [fromExpr, _emitTypeName(to)]);
   }
 
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
@@ skipping 769 matching lines @@
     }
 
     for (var f in fields.keys) unsetFields.remove(f);
 
     // Initialize all remaining fields
     unsetFields.forEach((element, fieldNode) {
       JS.Expression value;
       if (fieldNode.initializer != null) {
         value = _visit(fieldNode.initializer);
       } else {
-        var type = rules.elementType(element);
         value = new JS.LiteralNull();
-        if (rules.maybeNonNullableType(type)) {
-          value = js.call('dart.as(#, #)', [value, _emitTypeName(type)]);
-        }
       }
       fields[element] = value;
     });
 
     var body = <JS.Statement>[];
     fields.forEach((FieldElement e, JS.Expression initialValue) {
       var access = _emitMemberName(e.name, type: e.enclosingElement.type);
       body.add(js.statement('this.# = #;', [access, initialValue]));
     });
 
@@ skipping 1024 matching lines @@
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
   bool _isJSBuiltinType(DartType t) =>
       typeIsPrimitiveInJS(t) || t == _types.stringType;
 
   bool typeIsPrimitiveInJS(DartType t) =>
       _isNumberInJS(t) || t == _types.boolType;
 
-  bool typeIsNonNullablePrimitiveInJS(DartType t) =>
-      typeIsPrimitiveInJS(t) && rules.isNonNullableType(t);
-
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   bool _isNonNullableExpression(Expression expr) {
-    // If the type is non-nullable, no further checking needed.
-    if (rules.isNonNullableType(getStaticType(expr))) return true;
-
     // TODO(vsm): Revisit whether we really need this when we get
     // better non-nullability in the type system.
     // TODO(jmesserly): we do recursive calls in a few places. This could
     // leads to O(depth) cost for calling this function. We could store the
     // resulting value if that becomes an issue, so we maintain the invariant
     // that each node is visited once.
 
     if (expr is Literal && expr is! NullLiteral) return true;
     if (expr is IsExpression) return true;
     if (expr is ThisExpression) return true;
@@ skipping 1133 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }