Add support for null-aware operators to the CPS-IR.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 707 matching lines @@
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     return irBuilder.buildDynamicGet(
         translateReceiver(receiver),
         selector);
   }
 
   @override
+  ir.Primitive visitIfNotNullDynamicPropertyGet(
+      ast.Send node,
+      ast.Node receiver,
+      Selector selector,
+      _) {
+    ir.Primitive builtReceiver = visit(receiver);

[Kevin Millikin (Google), 2015/05/29 11:02:03]

I don't completely understand how we decide what goes in the Builder and what
goes in the BuilderVisitor.

I *think* all of this function could be moved into a function in the Builder
that takes subbuild(receiver) and the selector.  The reason is that the
representation of e.?x might depend on the front end, but its translation once
we recognize it will always be the same.

Johnni, what do you say?

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Good point - I made some changes to reflect this. The code got a lot cleaner,
the builder has patterns for if-null and if-not-null-sends. The code here now is
practically identical to the unconditinonal case, except for the extra call to
check for null.

+    ir.Primitive condition = irBuilder.buildCheckNull(builtReceiver);
+    return irBuilder.buildConditional(
+        condition,
+        (builder) => builtReceiver,

[Kevin Millikin (Google), 2015/05/29 11:02:03]

We normally give a type annotation on closures:

(IrBuilder builder) => builtReceiver

(Though I don't like doing it. :) )

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Done.

+        (builder) => builder.buildDynamicGet(builtReceiver, selector));
+  }
+
+  @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
     return irBuilder.buildConstant(constant);
   }
 
   @override
   ir.Primitive visitLocalVariableGet(
       ast.Send node,
@@ skipping 101 matching lines @@
       return withBuilder(rightBuilder, () => visit(right));
     }
 
     return irBuilder.buildLogicalOperator(
         leftValue, buildRightValue, isLazyOr: isLazyOr);
   }
 
   @override
   ir.Primitive visitIfNull(
       ast.Send node, ast.Node left, ast.Node right, _) {
-    internalError(node, "If-null not yet implemented in cps_ir");
+    ir.Primitive receiver = build(left);
+    ir.Primitive condition = irBuilder.buildCheckNull(receiver);
+    return irBuilder.buildConditional(
+        condition,
+        subbuild(right),
+        (IrBuilder b) => receiver);

[Kevin Millikin (Google), 2015/05/29 11:02:03]

Inconsistently named (the other's are all 'builder').

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Done.

   }
 
   @override
   ir.Primitive visitLogicalAnd(
       ast.Send node, ast.Node left, ast.Node right, _) {
     return translateLogicalOperator(left, right, isLazyOr: false);
   }
 
   @override
   ir.Primitive visitLogicalOr(
@@ skipping 198 matching lines @@
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return irBuilder.buildDynamicInvocation(
         translateReceiver(receiver), selector,
         translateDynamicArguments(arguments, selector.callStructure));
   }
 
+  @override
+  ir.Primitive visitIfNotNullDynamicPropertyInvoke(
+      ast.Send node,
+      ast.Node receiver,
+      ast.NodeList arguments,
+      Selector selector,
+      _) {
+    ir.Primitive builtReceiver = visit(receiver);
+    ir.Primitive condition = irBuilder.buildCheckNull(builtReceiver);
+    return irBuilder.buildConditional(
+        condition,
+        (builder) => builtReceiver,
+        (builder) => withBuilder(builder,  () =>

[Johnni Winther, 2015/05/29 10:23:24]

Introduce helper function in IrBuilderMixin for this pattern. (As discussed in
VC).

[Siggi Cherem (dart-lang), 2015/05/29 18:14:05]

Done. Much better

+          builder.buildDynamicInvocation(builtReceiver, selector,
+              translateDynamicArguments(arguments, selector.callStructure))));
+  }
+
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildLocalVariableInvocation(element, callStructure,
         translateDynamicArguments(arguments, callStructure));
   }
 
@@ skipping 170 matching lines @@
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
   }
 
   ir.Primitive translateCompounds(
       {ir.Primitive getValue(),
        CompoundRhs rhs,
        void setValue(ir.Primitive value)}) {
     ir.Primitive value = getValue();
-    Selector operatorSelector =
-        new Selector.binaryOperator(rhs.operator.selectorName);
-    ir.Primitive rhsValue;
-    if (rhs.kind == CompoundKind.ASSIGNMENT) {
-      rhsValue = visit(rhs.rhs);
+    op.BinaryOperator operator = rhs.operator;
+    if (operator.kind == op.BinaryOperatorKind.IF_NULL) {
+      // Unlike other compound operators if-null conditionally will not do the
+      // assignment operation.
+      return irBuilder.buildConditional(
+          irBuilder.buildCheckNull(value),
+          (builder) => withBuilder(builder, () {
+            ir.Primitive newValue = visit(rhs.rhs);
+            setValue(newValue);
+            return newValue;
+          }),
+          (builder) => value);
     } else {
-      rhsValue = irBuilder.buildIntegerConstant(1);
+      Selector operatorSelector =
+          new Selector.binaryOperator(operator.selectorName);
+      ir.Primitive rhsValue;
+      if (rhs.kind == CompoundKind.ASSIGNMENT) {
+        rhsValue = visit(rhs.rhs);
+      } else {
+        rhsValue = irBuilder.buildIntegerConstant(1);
+      }
+      List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
+      arguments = normalizeDynamicArguments(
+          operatorSelector.callStructure, arguments);
+      ir.Primitive result =
+          irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
+      setValue(result);
+      return rhs.kind == CompoundKind.POSTFIX ? value : result;
     }
-    List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
-    arguments = normalizeDynamicArguments(
-        operatorSelector.callStructure, arguments);
-    ir.Primitive result =
-        irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
-    setValue(result);
-    return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
   @override
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Selector selector,
       ast.Node rhs,
       _) {
     return irBuilder.buildDynamicSet(
         translateReceiver(receiver),
         selector,
         visit(rhs));
   }
 
   @override
+  ir.Primitive visitIfNotNullDynamicPropertySet(
+      ast.SendSet node,
+      ast.Node receiver,
+      Selector selector,
+      ast.Node rhs,
+      _) {
+    ir.Primitive builtReceiver = visit(receiver);
+    ir.Primitive condition = irBuilder.buildCheckNull(builtReceiver);
+    return irBuilder.buildConditional(
+        condition,
+        (builder) => builtReceiver,
+        (builder) => withBuilder(builder, () =>
+            builder.buildDynamicSet(builtReceiver, selector, visit(rhs))));
+  }
+
+  @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
     return irBuilder.buildLocalVariableSet(element, visit(rhs));
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
@@ skipping 55 matching lines @@
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.Send node,
       ast.Node receiver,
       CompoundRhs rhs,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     ir.Primitive target = translateReceiver(receiver);
-    return translateCompounds(
-        getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          irBuilder.buildDynamicSet(target, setterSelector, result);
-        });
+    ir.Primitive helper() {
+      return translateCompounds(
+          getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
+          rhs: rhs,
+          setValue: (ir.Primitive result) {
+            irBuilder.buildDynamicSet(target, setterSelector, result);
+          });
+    }
+    if (node.isConditional) {
+      return irBuilder.buildConditional(
+          irBuilder.buildCheckNull(target),
+          (_) => target,
+          (builder) => withBuilder(builder, helper));
+    } else {
+      return helper();
+    }
   }
 
   ir.Primitive buildLocalNoSuchSetter(Local local, ir.Primitive value) {
     Selector selector = new Selector.setter(local.name, null);
     return buildStaticNoSuchMethod(selector, [value]);
   }
 
   @override
   ir.Primitive handleLocalCompounds(
       ast.SendSet node,
@@ skipping 1699 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }