Add support for ! and != to the new IR builder

sdk/lib/_internal/compiler/implementation/ir/ir_builder.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 932 matching lines @@
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.GETTER);
       ir.InvokeStatic invoke = new ir.InvokeStatic(element, selector, k, []);
       add(new ir.LetCont(k, invoke));
       return v;
     } else {
       return giveup(); // TODO: figure out what's missing here
     }
   }
 
+  ir.Primitive translateNot(ir.Primitive condition) {

[Kevin Millikin (Google), 2014/06/20 09:18:14]

Maybe "translate" is the wrong name, it's not translating anything and the
subexpression is already translated.

How about "buildNegation"?  (The spec calls ! negationOperator.)

[sigurdm, 2014/06/23 08:08:57]

Much better name, thanks

+    // ! e is translated as e ? false : true
+
+    // Add a continuation parameter for the result of the expression.
+    ir.Parameter resultParameter = new ir.Parameter(null);
+
+    ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
+    ir.Continuation thenContinuation = new ir.Continuation([]);
+    ir.Continuation elseContinuation = new ir.Continuation([]);
+
+    ir.Constant trueConstant =
+        new ir.Constant(constantSystem.createBool(true));
+    ir.Constant falseConstant =
+        new ir.Constant(constantSystem.createBool(false));
+
+    thenContinuation.body = new ir.LetPrim(falseConstant)
+        ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
+    elseContinuation.body = new ir.LetPrim(trueConstant)
+        ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
+
+    add(new ir.LetCont(joinContinuation,
+          new ir.LetCont(thenContinuation,
+            new ir.LetCont(elseContinuation,
+              new ir.Branch(new ir.IsTrue(condition),
+                            thenContinuation,
+                            elseContinuation)))));
+    return resultParameter;
+  }
+
   ir.Primitive translateLogicalOperator(ast.Operator op,
                                         ast.Expression left,
                                         ast.Expression right) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
     // The translation must convert both e0 and e1 to booleans and handle
     // local variable assignments in e1.
 
     ir.Primitive leftValue = visit(left);
     IrBuilder rightBuilder = new IrBuilder.delimited(this);
@@ skipping 81 matching lines @@
     ast.Operator op = node.selector;
     if (isUserDefinableOperator(op.source)) {
       return visitDynamicSend(node);
     }
     if (op.source == '&&' || op.source == '||') {
       assert(node.receiver != null);
       assert(!node.arguments.isEmpty);
       assert(node.arguments.tail.isEmpty);
       return translateLogicalOperator(op, node.receiver, node.arguments.head);
     }
+    if (op.source == "!") {
+      assert(node.receiver != null);
+      assert(node.arguments.isEmpty);
+      return translateNot(visit(node.receiver));
+    }
+    if (op.source == "!=") {
+      assert(node.receiver != null);
+      assert(!node.arguments.isEmpty);
+      assert(node.arguments.tail.isEmpty);
+      return translateNot(visitDynamicSend(node));
+    }
     return giveup();
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     // TODO(lry): support constructors / factory calls.
     if (element.isConstructor) return giveup();
@@ skipping 229 matching lines @@
   bool visitType(DartType type, Null _) => false;
 
   bool visitDynamicType(DynamicType type, Null _) => true;
 
   bool visitVoidType(VoidType type, Null _) => true;
 
   // Currently, InterfaceType and TypedefType are supported so long as they
   // do not have type parameters.  They are subclasses of GenericType.
   bool visitGenericType(GenericType type, Null _) => !type.isGeneric;
 }