Handle more boolean conversion cases.

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 3450 matching lines @@
   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);
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
+
+    // The operands of logical boolean operators are subject to boolean
+    // conversion.
+    if (op.type == TokenType.BAR_BAR ||
+        op.type == TokenType.AMPERSAND_AMPERSAND) {
+      return _visitTest(node);

[Jennifer Messerly, 2016/06/07 19:28:35]

Reading this, I was confused ... my thought was "shouldn't the check be on the
operands, not the result?"

I see that _visitTest is implemented to "push down" the check, so it works. Not
sure if it's worth a comment.

It does seem pretty cool that _visitTest is the place with the knowledge of all
boolean operations. I wonder if _emitBooleanOperation or something like that
might describe its role (just brainstorming ... not sure the right name).

+    }
+
     var left = node.leftOperand;
     var right = node.rightOperand;
 
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if both sides are the same primitive type.
@@ skipping 435 matching lines @@
       ..staticElement = node.staticElement
       ..staticType = getStaticType(expr);
 
     var body = <JS.Expression>[_emitSet(left, increment), _visit(x)];
     return new JS.MetaLet(vars, body, statelessResult: true);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
+
+    // Logical negation, `!e`, is a boolean conversion context since it is
+    // defined as `e ? false : true`.
+    if (op.lexeme == '!') return _visitTest(node);
+
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (op.lexeme == '~') {
         if (_isNumberInJS(dispatchType)) {
           JS.Expression jsExpr = js.call('~#', notNull(expr));
           return _coerceBitOperationResultToUnsigned(node, jsExpr);
         }
         return _emitSend(expr, op.lexeme[0], []);
@@ skipping 1037 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';