Support binary expressions in analyzer2dart.

pkg/analyzer2dart/lib/src/cps_generator.dart

 // Copyright (c) 2014, 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 analyzer2dart.cps_generator;
 
 import 'package:analyzer/analyzer.dart';
 
 import 'package:compiler/implementation/elements/elements.dart' as dart2js;
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 169 matching lines @@
   ir.Node visitStaticFieldAccess(AstNode node, AccessSemantics semantics) {
     analyzer.Element element = semantics.element;
     dart2js.Element target = converter.convertElement(element);
     // TODO(johnniwinther): Selector information should be computed in the
     // [TreeShaker] and shared with the [CpsGeneratingVisitor].
     assert(invariant(node, target.isTopLevel || target.isStatic,
                      '$target expected to be top-level or static.'));
     return irBuilder.buildStaticGet(target,
         new Selector.getter(target.name, target.library));
   }
+
+  ir.Primitive handleBinaryExpression(BinaryExpression node,
+                                      String op) {
+    ir.Primitive left = node.leftOperand.accept(this);
+    ir.Primitive right = node.rightOperand.accept(this);
+    Selector selector = new Selector.binaryOperator(op);
+    return irBuilder.buildDynamicInvocation(
+        left, selector, <ir.Definition>[right]);
+  }
+
+  ir.Node handleLazyOperator(BinaryExpression node, {bool isLazyOr: false}) {
+    ir.Primitive left = node.leftOperand.accept(this);
+    ir.Primitive buildRightValue(IrBuilder builder) {
+      return withBuilder(builder, () => node.rightOperand.accept(this));
+    }
+    return irBuilder.buildLogicalOperator(
+        left, buildRightValue, isLazyOr: isLazyOr);
+  }
+
+  @override
+  ir.Node visitBinaryExpression(BinaryExpression node) {
+    // TODO(johnniwinther,paulberry,brianwilkerson): The operator should be
+    // available through an enum.
+    String op = node.operator.lexeme;
+    switch (op) {
+    case '||':
+    case '&&':
+      return handleLazyOperator(node, isLazyOr: op == '||');
+    case '!=':
+      return irBuilder.buildNegation(handleBinaryExpression(node, '=='));
+    default:
+      return handleBinaryExpression(node, op);
+    }
+  }
 }