Make int and double nullable by default

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 ddc.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 1029 matching lines @@
           rules.isNumType(t));
 
   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) {

[Jennifer Messerly, 2015/03/03 19:14:30]

add a TODO that this will go away when we have not-nullable types in the type
system?

it's nice, but a shame we'll lose info if you assign an expr to a variable.

[vsm, 2015/03/03 19:29:41]

Done.

+    if (expr is Literal && expr is! NullLiteral) {
+      return true;
+    }
+    if (expr is ParenthesizedExpression) {
+      return _isNonNullableExpression(expr.expression);
+    }
+    DartType type = null;
+    if (expr is BinaryExpression) {
+      type = rules.getStaticType(expr.leftOperand);
+    } else if (expr is PrefixExpression) {
+      type = rules.getStaticType(expr.operand);
+    } else if (expr is PostfixExpression) {
+      type = rules.getStaticType(expr.operand);
+    }
+    if (type != null && typeIsPrimitiveInJS(type)) {
+      return true;
+    }
+    return false;
+  }
+
   JS.Expression notNull(Expression expr) {
     var type = rules.getStaticType(expr);
-    if (rules.isNonNullableType(type)) {
+    if (rules.isNonNullableType(type) || _isNonNullableExpression(expr)) {
       return _visit(expr);
     } else {
       return js.call('dart.notNull(#)', _visit(expr));
     }
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
@@ skipping 853 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }