null-aware operators in the VM

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 1317 matching lines @@
     } else {
       EffectGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       if (node->kind() == Token::kAND) {
         Join(for_left, for_right, empty);
       } else {
         Join(for_left, empty, for_right);
       }
     }
     return;
+  } else if (node->kind() == Token::kIFNULL) {
+    // left ?? right. This operation cannot be overloaded.
+    // temp = left; temp === null ? right : temp
+    ValueGraphVisitor for_left_value(owner());
+    node->left()->Visit(&for_left_value);
+    Append(for_left_value);
+    Do(BuildStoreExprTemp(for_left_value.value()));
+
+    LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
+    LoadLocalNode* load_temp =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, temp_var);
+    LiteralNode* null_constant =
+        new(Z) LiteralNode(Scanner::kNoSourcePos, Object::null_instance());
+    ComparisonNode* check_is_null =
+        new(Z) ComparisonNode(Scanner::kNoSourcePos,
+                              Token::kEQ_STRICT,
+                              load_temp,
+                              null_constant);
+    TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
+    check_is_null->Visit(&for_test);
+
+    ValueGraphVisitor for_right_value(owner());
+    node->right()->Visit(&for_right_value);
+    for_right_value.Do(BuildStoreExprTemp(for_right_value.value()));
+
+    ValueGraphVisitor for_temp(owner());
+    // Nothing to do, left value is already loaded into temp.
+
+    Join(for_test, for_right_value, for_temp);
+    return;
   }
   ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
@@ skipping 55 matching lines @@
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner());
       Value* constant_true = for_true.Bind(new(Z) ConstantInstr(Bool::True()));
       for_true.Do(BuildStoreExprTemp(constant_true));
       Join(for_test, for_true, for_right);
     }
     ReturnDefinition(BuildLoadExprTemp());
     return;
+  } else if (node->kind() == Token::kIFNULL) {
+    // left ?? right. This operation cannot be overloaded.
+    // temp = left; temp === null ? right : temp

[Florian Schneider, 2015/06/18 14:09:00]

Is this the same code as in EffectGraphVisitor::VisitBinaryNode?

I wonder if this can be expressed easier using a LetNode and a
ConditionalExprNode. This way, just one call to visit would build the graph for
you and it would result in less duplicated code.

[hausner, 2015/06/18 17:55:37]

There is some duplication here that I would like to clean up in a later checkin
if you don't mind.

I started out using ConditinoalExpr and Let nodes to implement this, but the
parser code to deal with assignments (turning right-hand expressions into
left-hand sides) got very ugly.

+    ValueGraphVisitor for_left_value(owner());
+    node->left()->Visit(&for_left_value);
+    Append(for_left_value);
+    Do(BuildStoreExprTemp(for_left_value.value()));
+
+    LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
+    LoadLocalNode* load_temp =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, temp_var);
+    LiteralNode* null_constant =
+        new(Z) LiteralNode(Scanner::kNoSourcePos, Object::null_instance());
+    ComparisonNode* check_is_null =
+        new(Z) ComparisonNode(Scanner::kNoSourcePos,
+                              Token::kEQ_STRICT,
+                              load_temp,
+                              null_constant);
+    TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
+    check_is_null->Visit(&for_test);
+
+    ValueGraphVisitor for_right_value(owner());
+    node->right()->Visit(&for_right_value);
+    for_right_value.Do(BuildStoreExprTemp(for_right_value.value()));
+
+    ValueGraphVisitor for_temp(owner());
+    // Nothing to do, left value is already loaded into temp.
+
+    Join(for_test, for_right_value, for_temp);
+    ReturnDefinition(BuildLoadExprTemp());
+    return;
   }
+
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 static const String& BinaryOpAndMaskName(BinaryOpNode* node) {
   if (node->kind() == Token::kSHL) {
     return Library::PrivateCoreLibName(Symbols::_leftShiftWithMask32());
   }
   UNIMPLEMENTED();
   return String::ZoneHandle(Thread::Current()->zone(), String::null());
@@ skipping 1272 matching lines @@
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
-  ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(Z) ZoneGrowableArray<PushArgumentInstr*>(
-          node->arguments()->length() + 1);
-  arguments->Add(push_receiver);
+  if (node->is_conditional()) {
+    Do(BuildStoreExprTemp(for_receiver.value()));
+    LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
+    LoadLocalNode* load_temp =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, temp_var);
 
-  BuildPushArguments(*node->arguments(), arguments);
-  InstanceCallInstr* call = new(Z) InstanceCallInstr(
-      node->token_pos(),
-      node->function_name(),
-      Token::kILLEGAL,
-      arguments,
-      node->arguments()->names(),
-      1,
-      owner()->ic_data_array());
-  ReturnDefinition(call);
+    LiteralNode* null_constant =
+        new(Z) LiteralNode(Scanner::kNoSourcePos, Object::null_instance());
+    ComparisonNode* check_is_null =
+        new(Z) ComparisonNode(Scanner::kNoSourcePos,
+                              Token::kEQ,
+                              load_temp,
+                              null_constant);
+    TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
+    check_is_null->Visit(&for_test);
+
+    EffectGraphVisitor for_true(owner());
+    EffectGraphVisitor for_false(owner());
+
+    StoreLocalNode* store_null =
+        new(Z) StoreLocalNode(Scanner::kNoSourcePos, temp_var, null_constant);
+    store_null->Visit(&for_true);
+
+    InstanceCallNode* call =
+        new(Z) InstanceCallNode(node->token_pos(),
+                                load_temp,
+                                node->function_name(),
+                                node->arguments());
+    StoreLocalNode* store_result =
+        new(Z) StoreLocalNode(Scanner::kNoSourcePos, temp_var, call);
+    store_result->Visit(&for_false);
+
+    Join(for_test, for_true, for_false);
+    ReturnDefinition(BuildLoadExprTemp());
+  } else {
+    PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new(Z) ZoneGrowableArray<PushArgumentInstr*>(
+            node->arguments()->length() + 1);
+    arguments->Add(push_receiver);
+
+    BuildPushArguments(*node->arguments(), arguments);
+    InstanceCallInstr* call = new(Z) InstanceCallInstr(
+        node->token_pos(),
+        node->function_name(),
+        Token::kILLEGAL,
+        arguments,
+        node->arguments()->names(),
+        1,
+        owner()->ic_data_array());
+    ReturnDefinition(call);
+  }
 }
 
 
 static intptr_t GetResultCidOfNativeFactory(const Function& function) {
   const Class& function_class = Class::Handle(function.Owner());
   if (function_class.library() == Library::TypedDataLibrary()) {
     const String& function_name = String::Handle(function.name());
     if (!String::EqualsIgnoringPrivateKey(function_name, Symbols::_New())) {
       return kDynamicCid;
     }
@@ skipping 324 matching lines @@
     BuildConstructorCall(node, push_allocated_value);
     ReturnDefinition(ExitTempLocalScope(tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
-  ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new(Z) ZoneGrowableArray<PushArgumentInstr*>(1);
-  arguments->Add(push_receiver);
-  const String& name =
-      String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
-  InstanceCallInstr* call = new(Z) InstanceCallInstr(
-      node->token_pos(),
-      name,
-      Token::kGET,
-      arguments, Object::null_array(),
-      1,
-      owner()->ic_data_array());
-  ReturnDefinition(call);
+  if (node->is_conditional()) {
+    Do(BuildStoreExprTemp(for_receiver.value()));
+    LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
+    LoadLocalNode* load_temp =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, temp_var);
+
+    LiteralNode* null_constant =
+        new(Z) LiteralNode(Scanner::kNoSourcePos, Object::null_instance());
+    ComparisonNode* check_is_null =
+        new(Z) ComparisonNode(Scanner::kNoSourcePos,
+                              Token::kEQ,
+                              load_temp,
+                              null_constant);
+    TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
+    check_is_null->Visit(&for_test);
+
+    EffectGraphVisitor for_true(owner());
+    EffectGraphVisitor for_false(owner());
+
+    StoreLocalNode* store_null =
+        new(Z) StoreLocalNode(Scanner::kNoSourcePos, temp_var, null_constant);
+    store_null->Visit(&for_true);
+
+    InstanceGetterNode* getter =
+        new(Z) InstanceGetterNode(node->token_pos(),
+                                  load_temp,
+                                  node->field_name());
+    StoreLocalNode* store_getter =
+        new(Z) StoreLocalNode(Scanner::kNoSourcePos, temp_var, getter);
+    store_getter->Visit(&for_false);
+
+    Join(for_test, for_true, for_false);
+    ReturnDefinition(BuildLoadExprTemp());
+  } else {
+    PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new(Z) ZoneGrowableArray<PushArgumentInstr*>(1);
+    arguments->Add(push_receiver);
+    const String& name =
+        String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
+    InstanceCallInstr* call = new(Z) InstanceCallInstr(
+        node->token_pos(),
+        name,
+        Token::kGET,
+        arguments, Object::null_array(),
+        1,
+        owner()->ic_data_array());
+    ReturnDefinition(call);
+  }
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   arguments->Add(PushArgument(for_receiver.value()));
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
+  if (node->is_conditional()) {
+    ValueGraphVisitor for_receiver(owner());
+    node->receiver()->Visit(&for_receiver);
+    Append(for_receiver);
+    Do(BuildStoreExprTemp(for_receiver.value()));
+
+    LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
+    LoadLocalNode* load_temp =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, temp_var);
+    LiteralNode* null_constant =
+        new(Z) LiteralNode(Scanner::kNoSourcePos, Object::null_instance());
+    ComparisonNode* check_is_null =
+        new(Z) ComparisonNode(Scanner::kNoSourcePos,
+                              Token::kEQ,
+                              load_temp,
+                              null_constant);
+    TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
+    check_is_null->Visit(&for_test);
+
+    EffectGraphVisitor for_true(owner());
+    EffectGraphVisitor for_false(owner());
+
+    InstanceSetterNode* setter =
+        new(Z) InstanceSetterNode(node->token_pos(),
+                                  load_temp,
+                                  node->field_name(),
+                                  node->value());
+    setter->Visit(&for_false);
+    Join(for_test, for_true, for_false);
+    return;
+  }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   InstanceCallInstr* call = new(Z) InstanceCallInstr(node->token_pos(),
                                                      name,
                                                      Token::kSET,
                                                      arguments,
                                                      Object::null_array(),
                                                      kNumArgsChecked,
                                                      owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
+  if (node->is_conditional()) {
+    ValueGraphVisitor for_receiver(owner());
+    node->receiver()->Visit(&for_receiver);
+    Append(for_receiver);
+    Do(BuildStoreExprTemp(for_receiver.value()));
+
+    LocalVariable* temp_var = owner()->parsed_function().expression_temp_var();
+    LoadLocalNode* load_temp =
+        new(Z) LoadLocalNode(Scanner::kNoSourcePos, temp_var);
+    LiteralNode* null_constant =
+        new(Z) LiteralNode(Scanner::kNoSourcePos, Object::null_instance());
+    ComparisonNode* check_is_null =
+        new(Z) ComparisonNode(Scanner::kNoSourcePos,
+                              Token::kEQ,
+                              load_temp,
+                              null_constant);
+    TestGraphVisitor for_test(owner(), Scanner::kNoSourcePos);
+    check_is_null->Visit(&for_test);
+
+    ValueGraphVisitor for_true(owner());
+    null_constant->Visit(&for_true);
+    for_true.Do(BuildStoreExprTemp(for_true.value()));
+
+    ValueGraphVisitor for_false(owner());
+    InstanceSetterNode* setter =
+        new(Z) InstanceSetterNode(node->token_pos(),
+                                  load_temp,
+                                  node->field_name(),
+                                  node->value());
+    setter->Visit(&for_false);
+    for_false.Do(BuildStoreExprTemp(for_false.value()));
+
+    Join(for_test, for_true, for_false);
+    ReturnDefinition(BuildLoadExprTemp());
+    return;
+  }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   Do(new(Z) InstanceCallInstr(node->token_pos(),
                               name,
                               Token::kSET,
                               arguments,
@@ skipping 1392 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart