fuse some null checks with type checks, introduce a special bool variant

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 428 matching lines @@
       if (export is ClassElement && export.typeParameters.isNotEmpty) {
         // Export the generic name as well.
         // TODO(jmesserly): revisit generic classes
         emitExport(export, suffix: r'$');
       }
       emitExport(export);
     }
   }
 
   @override
-  visitAsExpression(AsExpression node) {
-    var from = getStaticType(node.expression);
-    var to = node.type.type;
+  visitAsExpression(AsExpression node) =>
+      _emitCast(node.expression, to: node.type.type);
 
-    var fromExpr = _visit(node.expression);
+  /// Emits a cast and/or a null check (i.e. a cast to a non-null type).
+  JS.Expression _emitCast(Expression fromExpr,
+      {DartType to, bool checkNull: false}) {
+
+    var jsFrom = _visit(fromExpr);
+    var from = getStaticType(fromExpr);
+
+    JS.Expression maybeCheckNull(JS.Expression jsExpr) {

[Jennifer Messerly, 2016/05/10 23:42:12]

aside: it might be a better architecture to fuse the helper calls at the JS AST
level, rather than merge the code paths.

The reason the code path merge seemed okay: if we have not-null types, the "to"
type will encode this information, so notNull will just be a cast to a not null
type.

In other words, it's sort of groundwork for a future Dart language feature.
Maybe. :)

+      if (checkNull && isNullable(fromExpr)) {
+        return js.call('dart.notNull(#)', jsExpr);
+      }
+      return jsExpr;
+    }
 
     // Skip the cast if it's not needed.
-    if (rules.isSubtypeOf(from, to)) return fromExpr;
+    if (to == null || rules.isSubtypeOf(from, to)) {
+      return maybeCheckNull(jsFrom);
+    }
 
     // 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]);
+        // TODO(jmesserly): fuse this with notNull check.
+        return maybeCheckNull(js.call('dart.asInt(#)', [jsFrom]));
       }
 
       // A no-op in JavaScript.
-      return fromExpr;
+      return maybeCheckNull(jsFrom);
     }
 
-    return js.call('dart.as(#, #)', [fromExpr, _emitType(to)]);
+    if (to == types.boolType && checkNull) {
+      return js.call('dart.test(#)', _visit(fromExpr));
+    }
+
+    if (checkNull && isNullable(fromExpr)) {
+      return js.call('dart.asNotNull(#, #)', [jsFrom, _emitType(to)]);
+    } else {
+      return js.call('dart.as(#, #)', [jsFrom, _emitType(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;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
     if (typeofName != null) {
@@ skipping 2572 matching lines @@
   bool typeIsPrimitiveInJS(DartType t) =>
       _isNumberInJS(t) || t == types.boolType;
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   JS.Expression notNull(Expression expr) {
     if (expr == null) return null;
-    var jsExpr = _visit(expr);
-    if (!isNullable(expr)) return jsExpr;
-    return js.call('dart.notNull(#)', jsExpr);
+    if (expr is AsExpression) {
+      return _emitCast(expr.expression, to: expr.type.type, checkNull: true);
+    }
+    return _emitCast(expr, checkNull: true);
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
 
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
@@ skipping 1333 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';