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) {
+    // TODO(vsm): Revisit whether we really need this when we get
+    // better non-nullability in the type system.
+
+    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;
+    }
+    if (expr is MethodInvocation) {
+      // TODO(vsm): This logic overlaps with the resolver.
+      // Where is the best place to put this?
+      var e = expr.methodName.staticElement;
+      if (e is FunctionElement &&

[Jennifer Messerly, 2015/03/03 20:05:01]

at some point I wonder if we want a helper for this (my bad, using it twice in
the initial CL :) ). Anyway not a big deal though since it's not likely to
change.

+          e.library.name == '_foreign_helper' &&
+          e.name == 'JS') {
+        // Fix types for JS builtin calls.
+        //
+        // This code was taken from analyzer. It's not super sophisticated:
+        // only looks for the type name in dart:core, so we just copy it here.
+        //
+        // TODO(jmesserly): we'll likely need something that can handle a wider
+        // variety of types, especially when we get to JS interop.
+        var args = expr.argumentList.arguments;
+        if (args.isNotEmpty && args.first is SimpleStringLiteral) {
+          var types = args.first.stringValue;
+          if (!types.split('|').contains('Null')) {
+            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;
   }
 }