Support conditional expressions in analyzer2dart.

sdk/lib/_internal/compiler/implementation/cps_ir/cps_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 '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../dart_types.dart';
@@ skipping 337 matching lines @@
   ir.Constant buildNullLiteral() {
     return _buildPrimitiveConstant(state.constantSystem.createNull());
   }
 
   /// Create a string literal.
   ir.Constant buildStringLiteral(String value) {
     return _buildPrimitiveConstant(
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
+  /// Creates a conditional expression with the provided [condition] where the
+  /// then and else expression are created through the [buildThenExpression] and
+  /// [buildElseExpression] functions, respectively.
+  ir.Primitive buildConditional(
+      ir.Primitive condition,
+      ir.Primitive buildThenExpression(IrBuilder builder),
+      ir.Primitive buildElseExpression(IrBuilder builder)) {
+
+    assert(isOpen);
+
+    // The then and else expressions are delimited.
+    IrBuilder thenBuilder = new IrBuilder.delimited(this);
+    IrBuilder elseBuilder = new IrBuilder.delimited(this);
+    ir.Primitive thenValue = buildThenExpression(thenBuilder);
+    ir.Primitive elseValue = buildElseExpression(elseBuilder);
+
+    // Treat the values of the subexpressions as named values in the
+    // environment, so they will be treated as arguments to the join-point
+    // continuation.
+    assert(environment.length == thenBuilder.environment.length);
+    assert(environment.length == elseBuilder.environment.length);
+    thenBuilder.environment.extend(null, thenValue);
+    elseBuilder.environment.extend(null, elseValue);
+    JumpCollector jumps = new JumpCollector(null);
+    jumps.addJump(thenBuilder);
+    jumps.addJump(elseBuilder);
+    ir.Continuation joinContinuation =
+        createJoin(environment.length + 1, jumps);
+
+    // Build the term
+    //   let cont join(x, ..., result) = [] in
+    //   let cont then() = [[thenPart]]; join(v, ...) in
+    //   let cont else() = [[elsePart]]; join(v, ...) in
+    //     if condition (then, else)
+    ir.Continuation thenContinuation = new ir.Continuation([]);
+    ir.Continuation elseContinuation = new ir.Continuation([]);
+    thenContinuation.body = thenBuilder._root;
+    elseContinuation.body = elseBuilder._root;
+    add(new ir.LetCont(joinContinuation,
+            new ir.LetCont(thenContinuation,
+                new ir.LetCont(elseContinuation,
+                    new ir.Branch(new ir.IsTrue(condition),
+                                  thenContinuation,
+                                  elseContinuation)))));
+    return (thenValue == elseValue)
+        ? thenValue
+        : joinContinuation.parameters.last;
+
+  }
+
   /// Create a get access of [local].
   ir.Primitive buildLocalGet(Element local) {
     assert(isOpen);
     return environment.lookup(local);
   }
 
   /// Create a get access of the static [element].
   ir.Primitive buildStaticGet(Element element, Selector selector) {
     assert(isOpen);
     assert(selector.isGetter);
@@ skipping 72 matching lines @@
   /// Create a static invocation of [element] with arguments structure defined
   /// by [selector] and argument values defined by [arguments].
   ir.Primitive buildStaticInvocation(Element element,
                                      Selector selector,
                                      List<ir.Definition> arguments) {
     return continueWithExpression(
         (k) => new ir.InvokeStatic(element, selector, k, arguments));
   }
 
   /// Creates an if-then-else statement with the provided [condition] where the
-  /// then and else branches are created throught the [buildThenPart] and
+  /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   void buildIf(ir.Primitive condition,
                void buildThenPart(IrBuilder builder),
                void buildElsePart(IrBuilder builder)) {
     assert(isOpen);
 
     // The then and else parts are delimited.
     IrBuilder thenBuilder = new IrBuilder.delimited(this);
@@ skipping 313 matching lines @@
     index = 0;
     for (int i = 0; i < environment.length; ++i) {
       if (common[i] == null) {
         environment.index2value[i] = parameters[index++];
       }
     }
 
     return join;
   }
 }