Implementation of null-aware operators.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 3124 matching lines @@
              node.elsePart != null ? () => visit(node.elsePart) : null);
   }
 
   void handleIf(ast.Node diagnosticNode,
                 void visitCondition(), void visitThen(), void visitElse()) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
     branchBuilder.handleIf(visitCondition, visitThen, visitElse);
   }
 
   @override
+  void visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    brancher.handleIfNull(() => visit(left), () => visit(right));
+  }
+
+  @override
   void visitLogicalAnd(ast.Send node, ast.Node left, ast.Node right, _) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
     branchBuilder.handleLogicalAndOrWithLeftNode(
         left,
         () { visit(right); },
         isAnd: true);
   }
 
   @override
   void visitLogicalOr(ast.Send node, ast.Node left, ast.Node right, _) {
@@ skipping 236 matching lines @@
   @override
   void visitDynamicPropertyGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     generateDynamicGet(node);
   }
 
   @override
+  void visitIfNotNullDynamicPropertyGet(
+      ast.Send node,
+      ast.Node receiver,
+      Selector selector,
+      _) {
+    // exp?.x compiled as:
+    //   t1 = exp;
+    //   result = t1 == null ? null : t1.x;
+    visit(receiver);

[sra1, 2015/05/22 21:17:28]

I think we should visit(receiver) in the visitCondition thunk.

That would make 'exp' part of the subgraph for the whole expression rather than
being in the preceding block and associated with the containing expression.
(The SSA contains single-successor blocks to capture subgraphs that correspond
to subexpressions).
Expressions that are broken over subexpression subgraphs are harder to recognize
as idiomatic.

[Siggi Cherem (dart-lang), 2015/05/22 22:36:08]

Done.

+    HInstruction expression = pop();
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    brancher.handleConditional(() => pushCheckNull(expression),

[sra1, 2015/05/22 21:17:28]

It would look cleaner if this was on a new line.

[Siggi Cherem (dart-lang), 2015/05/22 22:36:08]

Done.

+        () => stack.add(graph.addConstantNull(compiler)),

[Siggi Cherem (dart-lang), 2015/05/22 03:50:49]

technically we know that t1 is null too, does it matter whether we use the
constant or t1? I kept it as null to make the code easier to understand, but I
was wondering if this matters for code size (t1 is 2 chars less).

+        () => generateInstanceGetterWithCompiledReceiver(
+            node, elements.getSelector(node), expression));
+  }
+
+  /// Pushes a boolean checking [expression] against null.
+  pushCheckNull(HInstruction expression) {
+    push(new HIdentity(expression, graph.addConstantNull(compiler),
+          null, backend.boolType));
+  }
+
+  @override
   void visitLocalVariableGet(ast.Send node, LocalVariableElement variable, _) {
     handleLocalGet(variable);
   }
 
   @override
   void visitParameterGet(ast.Send node, ParameterElement parameter, _) {
     handleLocalGet(parameter);
   }
 
   @override
@@ skipping 50 matching lines @@
   }
 
   @override
   void visitTopLevelGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
     generateStaticGetterGet(node, getter);
   }
 
+  void generatePossiblyConditionalInstanceSetter(ast.Send send,
+                                                 HInstruction receiver,
+                                                 HInstruction pushValue(),
+                                                 {Selector selector,
+                                                  ast.Node location}) {
+    if (send.isConditional) {
+      SsaBranchBuilder brancher = new SsaBranchBuilder(this, send);
+      // compile e?.x = e2 to:
+      //
+      // t1 = e
+      // if (t1 == null)
+      //   t1 = null;
+      // else
+      //   t1 = e.x = e2
+      brancher.handleConditional(
+          () => pushCheckNull(receiver),
+          () => stack.add(graph.addConstantNull(compiler)),
+          () => generateInstanceSetterWithCompiledReceiver(
+                    send, receiver, pushValue(),
+                    selector: selector, location: location));
+    } else {
+      generateInstanceSetterWithCompiledReceiver(send, receiver, pushValue(),
+          selector: selector, location: location);
+    }
+  }
+
   void generateInstanceSetterWithCompiledReceiver(ast.Send send,
                                                   HInstruction receiver,
                                                   HInstruction value,
                                                   {Selector selector,
                                                    ast.Node location}) {
     assert(send == null || Elements.isInstanceSend(send, elements));
     if (selector == null) {
       assert(send != null);
       selector = elements.getSelector(send);
     }
@@ skipping 242 matching lines @@
 
   void addGenericSendArgumentsToList(Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   /// Generate a dynamic method, getter or setter invocation.
   void generateDynamicSend(ast.Send node) {
+    HInstruction receiver = generateInstanceSendReceiver(node);
+    _generateDynamicSend(node, receiver);
+  }
+
+  void _generateDynamicSend(ast.Send node, HInstruction receiver) {
     Selector selector = elements.getSelector(node);
 
     List<HInstruction> inputs = <HInstruction>[];
-    HInstruction receiver = generateInstanceSendReceiver(node);
     inputs.add(receiver);
     addDynamicSendArgumentsToList(node, inputs);
 
     pushInvokeDynamic(node, selector, inputs);
     if (selector.isSetter || selector.isIndexSet) {
       pop();
       stack.add(inputs.last);
     }
   }
 
   @override
   visitDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     generateDynamicSend(node);
   }
 
   @override
+  visitIfNotNullDynamicPropertyInvoke(
+      ast.Send node,
+      ast.Node receiver,
+      ast.NodeList arguments,
+      Selector selector,
+      _) {
+    HInstruction receiver = generateInstanceSendReceiver(node);
+    SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+    brancher.handleConditional(() => pushCheckNull(receiver),
+        () => stack.add(graph.addConstantNull(compiler)),

[sra1, 2015/05/22 21:17:28]

We probably want to preserve the variant of null (JS null vs undefined).

x == null ? null : x.foo()
!=
x == null ? x : x.foo()

Only second one can later be converted into `x || x.foo()`.
Recognizing this will be easier if the receiver expression is brought into the
subgraph (see above).

The minified code is also shorter since locals are single letter vs `null`.

[Siggi Cherem (dart-lang), 2015/05/22 22:36:08]

Done.

+        () => _generateDynamicSend(node, receiver));
+  }
+
+  @override
   visitThisPropertyInvoke(
       ast.Send node,
       ast.NodeList arguments,
       Selector selector,
       _) {
     generateDynamicSend(node);
   }
 
   @override
   visitExpressionInvoke(
@@ skipping 1730 matching lines @@
     generateIsDeferredLoadedCheckOfSend(node);
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType) {
       ast.Identifier selector = node.selector;
       generateThrowNoSuchMethod(node, selector.source,
                                 argumentNodes: node.arguments);
       return;
     }
     ast.Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
-      HInstruction result;
       List<HInstruction> setterInputs = <HInstruction>[];
+      void generateSuperSendSet() {
+        Selector setterSelector = elements.getSelector(node);
+        if (Elements.isUnresolved(element)
+            || !setterSelector.applies(element, compiler.world)) {
+          generateSuperNoSuchMethodSend(
+              node, setterSelector, setterInputs);
+          pop();
+        } else {
+          add(buildInvokeSuper(setterSelector, element, setterInputs));
+        }
+      }
       if (identical(node.assignmentOperator.source, '=')) {
         addDynamicSendArgumentsToList(node, setterInputs);
-        result = setterInputs.last;
+        generateSuperSendSet();
+        stack.add(setterInputs.last);
       } else {
         Element getter = elements[node.selector];
         List<HInstruction> getterInputs = <HInstruction>[];
         Link<ast.Node> arguments = node.arguments;
         if (node.isIndex) {
           // If node is of the from [:super.foo[0] += 2:], the send has
           // two arguments: the index and the left hand side. We get
           // the index and add it as input of the getter and the
           // setter.
           visit(arguments.head);
           arguments = arguments.tail;
           HInstruction index = pop();
           getterInputs.add(index);
           setterInputs.add(index);
         }
         HInstruction getterInstruction;
         Selector getterSelector =
             elements.getGetterSelectorInComplexSendSet(node);
         if (Elements.isUnresolved(getter)) {
           generateSuperNoSuchMethodSend(
               node,
               getterSelector,
               getterInputs);
           getterInstruction = pop();
         } else {
           getterInstruction = buildInvokeSuper(
               getterSelector, getter, getterInputs);
           add(getterInstruction);
         }
-        handleComplexOperatorSend(node, getterInstruction, arguments);
-        setterInputs.add(pop());
 
-        if (node.isPostfix) {
-          result = getterInstruction;
+        if (node.isIfNullAssignment) {
+          SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+          brancher.handleIfNull(() => stack.add(getterInstruction),
+              () {
+                addDynamicSendArgumentsToList(node, setterInputs);
+                generateSuperSendSet();
+                stack.add(setterInputs.last);
+              });
         } else {
-          result = setterInputs.last;
+          handleComplexOperatorSend(node, getterInstruction, arguments);
+          setterInputs.add(pop());
+          generateSuperSendSet();
+          stack.add(node.isPostfix ? getterInstruction : setterInputs.last);
         }
       }
-      Selector setterSelector = elements.getSelector(node);
-      if (Elements.isUnresolved(element)
-          || !setterSelector.applies(element, compiler.world)) {
-        generateSuperNoSuchMethodSend(
-            node, setterSelector, setterInputs);
-        pop();
-      } else {
-        add(buildInvokeSuper(setterSelector, element, setterInputs));
-      }
-      stack.add(result);
     } else if (node.isIndex) {
       if ("=" == op.source) {
         generateDynamicSend(node);
       } else {
         visit(node.receiver);
         HInstruction receiver = pop();
         Link<ast.Node> arguments = node.arguments;
         HInstruction index;
         if (node.isIndex) {
           visit(arguments.head);
           arguments = arguments.tail;
           index = pop();
         }
 
         pushInvokeDynamic(
             node,
             elements.getGetterSelectorInComplexSendSet(node),
             [receiver, index]);
         HInstruction getterInstruction = pop();
-
-        handleComplexOperatorSend(node, getterInstruction, arguments);
-        HInstruction value = pop();
-
-        pushInvokeDynamic(
-            node, elements.getSelector(node), [receiver, index, value]);
-        pop();
-
-        if (node.isPostfix) {
-          stack.add(getterInstruction);
+        if (node.isIfNullAssignment) {
+          // Compile x[i] ??= e as:
+          //   t1 = x[i]
+          //   if (t1 == null)
+          //      t1 = x[i] = e;
+          //   result = t1
+          SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+          brancher.handleIfNull(() => stack.add(getterInstruction),
+              () {
+                visit(arguments.head);
+                HInstruction value = pop();
+                pushInvokeDynamic(
+                    node, elements.getSelector(node), [receiver, index, value]);
+                pop();
+                stack.add(value);
+              });
         } else {
-          stack.add(value);
+          handleComplexOperatorSend(node, getterInstruction, arguments);
+          HInstruction value = pop();
+          pushInvokeDynamic(
+              node, elements.getSelector(node), [receiver, index, value]);
+          pop();
+          if (node.isPostfix) {
+            stack.add(getterInstruction);
+          } else {
+            stack.add(value);
+          }
         }
       }
     } else if ("=" == op.source) {
       Link<ast.Node> link = node.arguments;
       assert(!link.isEmpty && link.tail.isEmpty);
       if (Elements.isInstanceSend(node, elements)) {
         HInstruction receiver = generateInstanceSendReceiver(node);
-        visit(link.head);
-        generateInstanceSetterWithCompiledReceiver(node, receiver, pop());
+        generatePossiblyConditionalInstanceSetter(node, receiver,
+            () => visitAndPop(link.head));
       } else {
         visit(link.head);
         generateNonInstanceSetter(node, element, pop());
       }
     } else if (identical(op.source, "is")) {
       compiler.internalError(op, "is-operator as SendSet.");
     } else {
       assert("++" == op.source || "--" == op.source ||
              node.assignmentOperator.source.endsWith("="));
 
-      // [receiver] is only used if the node is an instance send.
-      HInstruction receiver = null;
       Element getter = elements[node.selector];
 
       if (!Elements.isUnresolved(getter) && getter.impliesType) {
-        ast.Identifier selector = node.selector;
-        generateThrowNoSuchMethod(node, selector.source,
-                                  argumentNodes: node.arguments);
+        if (node.isIfNullAssignment) {
+          // C ??= x is compiled just as C.
+          stack.add(addConstant(node.selector));
+        } else {
+          ast.Identifier selector = node.selector;
+          generateThrowNoSuchMethod(node, selector.source,
+                                    argumentNodes: node.arguments);
+        }
         return;
-      } else if (Elements.isInstanceSend(node, elements)) {
-        receiver = generateInstanceSendReceiver(node);
-        generateInstanceGetterWithCompiledReceiver(
-            node, elements.getGetterSelectorInComplexSendSet(node), receiver);
-      } else if (getter.isErroneous) {
+      }
+
+      if (Elements.isInstanceSend(node, elements)) {
+        final HInstruction receiver = generateInstanceSendReceiver(node);
+        void generateAssignment() {
+          // desugarizes `e.x op= e2` as: `e.x = e.x op e2`

[sra1, 2015/05/22 21:17:28]

Desugars ... to: ...

+          generateInstanceGetterWithCompiledReceiver(
+              node, elements.getGetterSelectorInComplexSendSet(node), receiver);
+          HInstruction getterInstruction = pop();
+          if (node.isIfNullAssignment) {
+            SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+            brancher.handleIfNull(() => stack.add(getterInstruction),
+                () {
+                  visit(node.arguments.head);
+                  generateInstanceSetterWithCompiledReceiver(
+                      node, receiver, pop());
+                });
+          } else {
+            handleComplexOperatorSend(node, getterInstruction, node.arguments);
+            HInstruction value = pop();
+            generateInstanceSetterWithCompiledReceiver(node, receiver, value);
+          }
+          if (node.isPostfix) {
+            pop();
+            stack.add(getterInstruction);
+          }
+        }
+        if (node.isConditional) {
+          // generate `e?.x op= e2` as:
+          //   t1 = e
+          //   t1 == null ? null : (t1.x = t1.x op e2);
+          SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+          brancher.handleConditional(
+              () => pushCheckNull(receiver),
+              () => stack.add(graph.addConstantNull(compiler)),
+              generateAssignment);
+        } else {
+          generateAssignment();
+        }
+        return;
+      }
+
+      if (getter.isErroneous) {
         generateStaticUnresolvedGet(node, getter);
       } else if (getter.isField) {
         generateStaticFieldGet(node, getter);
       } else if (getter.isGetter) {
         generateStaticGetterGet(node, getter);
       } else if (getter.isFunction) {
         generateStaticFunctionGet(node, getter);
       } else if (getter.isLocal) {
         handleLocalGet(getter);
       } else {
         internalError(node, "Unexpected getter: $getter");
       }
       HInstruction getterInstruction = pop();
-      handleComplexOperatorSend(node, getterInstruction, node.arguments);
-      HInstruction value = pop();
-      assert(value != null);
-      if (Elements.isInstanceSend(node, elements)) {
-        assert(receiver != null);
-        generateInstanceSetterWithCompiledReceiver(node, receiver, value);
+      if (node.isIfNullAssignment) {
+        SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
+        brancher.handleIfNull(() => stack.add(getterInstruction),
+            () {
+              visit(node.arguments.head);
+              generateNonInstanceSetter(node, element, pop());
+            });
       } else {
-        assert(receiver == null);
+        handleComplexOperatorSend(node, getterInstruction, node.arguments);
+        HInstruction value = pop();
         generateNonInstanceSetter(node, element, value);
       }
       if (node.isPostfix) {
         pop();
         stack.add(getterInstruction);
       }
     }
   }
 
   void visitLiteralInt(ast.LiteralInt node) {
@@ skipping 1788 matching lines @@
     }
 
     _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
   }
 
   handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
     assert(visitElse != null);
     _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
   }
 
+  handleIfNull(void left(), void right()) {
+    // x ?? y is transformed into: x == null ? y : x
+    left();
+    HInstruction leftExpression = builder.pop();
+    handleConditional(
+        () => builder.pushCheckNull(leftExpression),

[sra1, 2015/05/22 21:17:28]

left() should be called in here.

[Siggi Cherem (dart-lang), 2015/05/22 22:36:08]

Done

+        right,
+        () => builder.stack.add(leftExpression));
+  }
+
   void handleLogicalAndOr(void left(), void right(), {bool isAnd}) {
     // x && y is transformed into:
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //   }
     //   result = phi(t1, false);
     //
     // x || y is transformed into:
     //   t0 = boolify(x);
@@ skipping 200 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }