VM: Fix bug with ??= expressions using await.

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 10548 matching lines @@
             (lhs->AsBinaryOpNode()->kind() == Token::kSHL)) {
           // Merge SHL and BIT_AND into one "SHL with mask" node.
           BinaryOpNode* old = lhs->AsBinaryOpNode();
           BinaryOpWithMask32Node* binop = new(Z) BinaryOpWithMask32Node(
               old->token_pos(), old->kind(), old->left(), old->right(), val);
           return binop;
         }
       }
     }
   }
+  if (binary_op == Token::kIFNULL) {
+    // Handle a ?? b.
+    const intptr_t no_pos = Scanner::kNoSourcePos;
+    LetNode* result = new(Z) LetNode(no_pos);
+    LocalVariable* left_temp = result->AddInitializer(lhs);
+    LiteralNode* null_operand =
+        new LiteralNode(no_pos, Instance::ZoneHandle(Z));
+    LoadLocalNode* load_left_temp = new(Z) LoadLocalNode(no_pos, left_temp);
+    ComparisonNode* null_compare =
+        new ComparisonNode(no_pos,
+                           Token::kNE_STRICT,
+                           load_left_temp,
+                           null_operand);
+    result->AddNode(new(Z) ConditionalExprNode(op_pos,
+                                               null_compare,
+                                               load_left_temp,
+                                               rhs));
+    return result;
+  }
   return new(Z) BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
 
 AstNode* Parser::ExpandAssignableOp(intptr_t op_pos,
                                     Token::Kind assignment_op,
                                     AstNode* lhs,
                                     AstNode* rhs) {
   TRACE_PARSER("ExpandAssignableOp");
   switch (assignment_op) {
@@ skipping 151 matching lines @@
   // Therefore, we need to transform a = (a ?? b) into a ?? (a = b)
   if (is_compound &&
       rhs->IsBinaryOpNode() &&
       (rhs->AsBinaryOpNode()->kind() == Token::kIFNULL)) {
     BinaryOpNode* ifnull = rhs->AsBinaryOpNode();
     AstNode* modified_assign =
         CreateAssignmentNode(original,
                              ifnull->right(),
                              left_ident,
                              left_pos);
-    result = new(Z) BinaryOpNode(rhs->token_pos(),
-                                 Token::kIFNULL,
-                                 ifnull->left(),
-                                 modified_assign);
+    const intptr_t no_pos = Scanner::kNoSourcePos;
+    LetNode* let_node = new(Z) LetNode(no_pos);

[hausner, 2015/11/03 19:03:08]

Should be possible to call OptimizeBinaryOpNode() here and re-use that code.

[Florian Schneider, 2015/11/03 19:10:59]

Yes, good point.

+    LocalVariable* left_temp = let_node->AddInitializer(ifnull->left());
+    LiteralNode* null_operand =
+        new LiteralNode(no_pos, Instance::ZoneHandle(Z));
+    LoadLocalNode* load_left_temp = new(Z) LoadLocalNode(no_pos, left_temp);
+    ComparisonNode* null_compare =
+        new ComparisonNode(no_pos,
+                           Token::kNE_STRICT,
+                           load_left_temp,
+                           null_operand);
+    let_node->AddNode(new(Z) ConditionalExprNode(rhs->token_pos(),
+                                                 null_compare,
+                                                 load_left_temp,
+                                                 modified_assign));
+    result = let_node;
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
   LetNode* cascade = new(Z) LetNode(cascade_pos);
   LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
@@ skipping 3577 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart