null-aware operators in the VM

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 2961 matching lines @@
     // is the "super call" and is implicitly at the end of the
     // initializer list.
     ASSERT(!is_redirecting_constructor);
     ArgumentListNode* ctor_args = super_call->arguments();
     // The super initializer call has at least 2 arguments: the
     // implicit receiver, and the hidden construction phase.
     ASSERT(ctor_args->length() >= 2);
     for (int i = 2; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
       if (!IsSimpleLocalOrLiteralNode(arg)) {
-        LocalVariable* temp =
-            CreateTempConstVariable(arg->token_pos(), "sca");
+        LocalVariable* temp = CreateTempConstVariable(arg->token_pos(), "sca");
         AstNode* save_temp = new StoreLocalNode(arg->token_pos(), temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
   intptr_t body_pos = TokenPos();
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
@@ skipping 4135 matching lines @@
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new(Z) LoadLocalNode(TokenPos(), receiver);
 }
 
 
-AstNode* Parser::CallGetter(intptr_t token_pos,
-                            AstNode* object,
-                            const String& name) {
+InstanceGetterNode* Parser::CallGetter(intptr_t token_pos,
+                                       AstNode* object,
+                                       const String& name) {
   return new(Z) InstanceGetterNode(token_pos, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const,
                                           SequenceNode** await_preamble) {
   TRACE_PARSER("ParseVariableDeclaration");
@@ skipping 2982 matching lines @@
   arguments->Add(new(Z) LiteralNode(call_pos, array));
 
   return MakeStaticCall(Symbols::NoSuchMethodError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
-  ASSERT(min_preced >= Token::Precedence(Token::kOR));
+  ASSERT(min_preced >= Token::Precedence(Token::kIFNULL));
   AstNode* left_operand = ParseUnaryExpr();
   if (left_operand->IsPrimaryNode() &&
       (left_operand->AsPrimaryNode()->IsSuper())) {
     ReportError(left_operand->token_pos(), "illegal use of 'super'");
   }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
       const intptr_t op_pos = TokenPos();
@@ skipping 29 matching lines @@
           let->AddNode(left_operand);
           let->AddNode(ThrowTypeError(type_pos, type));
           left_operand = let;
           break;  // Type checks and casts can't be chained.
         }
       }
       if (Token::IsRelationalOperator(op_kind)
           || Token::IsTypeTestOperator(op_kind)
           || Token::IsTypeCastOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
-        if (Token::IsTypeTestOperator(op_kind) ||
-            Token::IsTypeCastOperator(op_kind)) {
-          if (!right_operand->AsTypeNode()->type().IsInstantiated()) {
-            EnsureExpressionTemp();
-          }
-        }
         left_operand = new(Z) ComparisonNode(
             op_pos, op_kind, left_operand, right_operand);
         break;  // Equality and relational operators cannot be chained.
       } else {
         left_operand = OptimizeBinaryOpNode(
             op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
@@ skipping 62 matching lines @@
         rhs_literal->literal().IsDouble()) {
       double left_double = Double::Cast(lhs_literal->literal()).value();
       double right_double = Double::Cast(rhs_literal->literal()).value();
       if (binary_op == Token::kDIV) {
         const Double& dbl_obj = Double::ZoneHandle(Z,
             Double::NewCanonical((left_double / right_double)));
         return new(Z) LiteralNode(op_pos, dbl_obj);
       }
     }
   }
-  if ((binary_op == Token::kAND) || (binary_op == Token::kOR)) {
-    EnsureExpressionTemp();
-  }
   if (binary_op == Token::kBIT_AND) {
     // Normalize so that rhs is a literal if any is.
     if ((rhs_literal == NULL) && (lhs_literal != NULL)) {
       // Swap.
       LiteralNode* temp = rhs_literal;
       rhs_literal = lhs_literal;
       lhs_literal = temp;
     }
     if ((rhs_literal != NULL) &&
         (rhs_literal->literal().IsSmi() || rhs_literal->literal().IsMint())) {
@@ skipping 37 matching lines @@
     case Token::kASSIGN_SHR:
       return new(Z) BinaryOpNode(op_pos, Token::kSHR, lhs, rhs);
     case Token::kASSIGN_SHL:
       return new(Z) BinaryOpNode(op_pos, Token::kSHL, lhs, rhs);
     case Token::kASSIGN_OR:
       return new(Z) BinaryOpNode(op_pos, Token::kBIT_OR, lhs, rhs);
     case Token::kASSIGN_AND:
       return new(Z) BinaryOpNode(op_pos, Token::kBIT_AND, lhs, rhs);
     case Token::kASSIGN_XOR:
       return new(Z) BinaryOpNode(op_pos, Token::kBIT_XOR, lhs, rhs);
+    case Token::kASSIGN_COND:
+      return new(Z) BinaryOpNode(op_pos, Token::kIFNULL, lhs, rhs);
     default:
       ReportError(op_pos,
                   "internal error: ExpandAssignableOp '%s' unimplemented",
                   Token::Name(assignment_op));
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
 
@@ skipping 35 matching lines @@
     return result;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* getter = node->AsInstanceGetterNode();
     AstNode* receiver = getter->receiver();
     if (!IsSimpleLocalOrLiteralNode(getter->receiver())) {
       LocalVariable* t0 = result->AddInitializer(getter->receiver());
       receiver = new(Z) LoadLocalNode(token_pos, t0);
     }
     *expr = new(Z) InstanceGetterNode(
-        token_pos, receiver, getter->field_name());
+        token_pos, receiver, getter->field_name(), getter->is_conditional());
     return result;
   }
   return result;
 }
 
 
 // Check whether the syntax of expression expr is a grammatically legal
 // assignable expression. This check is used to detect situations where
 // the expression itself is assignable, but the source is grammatically
 // wrong. The AST representation of an expression cannot distinguish
@@ skipping 42 matching lines @@
     let_node->AddNode(ThrowNoSuchMethodError(
          original->token_pos(),
          *target_cls,
          String::Handle(Z, Field::SetterName(name)),
          NULL,  // No arguments.
          InvocationMirror::kStatic,
          original->IsLoadLocalNode() ?
          InvocationMirror::kLocalVar : InvocationMirror::kSetter,
          NULL));  // No existing function.
     result = let_node;
-  } else if (result->IsStoreIndexedNode() ||
-             result->IsInstanceSetterNode() ||
-             result->IsStaticSetterNode() ||
-             result->IsStoreStaticFieldNode() ||
-             result->IsStoreLocalNode()) {
-    // Ensure that the expression temp is allocated for nodes that may need it.
-    EnsureExpressionTemp();
+  }
+  // The compound assignment operator a ??= b is different from other
+  // a op= b assignments. If a is non-null, the assignment to a must be
+  // dropped:
+  // normally: a op= b ==> a = a op b
+  // however:  a ??= b ==> a ?? (a = b)
+  // Therefore, we need to transform a = (a ?? b) into a ?? (a = b)
+  if (rhs->IsBinaryOpNode() &&
+      (rhs->AsBinaryOpNode()->kind() == Token::kIFNULL)) {
+    BinaryOpNode* ifnull = rhs->AsBinaryOpNode();
+    AstNode* modified_assign =
+        CreateAssignmentNode(ifnull->left(),
+                             ifnull->right(),
+                             left_ident,
+                             left_pos);
+    result = new(Z) BinaryOpNode(rhs->token_pos(),
+                                 Token::kIFNULL,
+                                 original,
+                                 modified_assign);
   }
   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 161 matching lines @@
   if (!expr->IsLiteralNode()) {
     ReportError(expr_pos, "expression must be a compile-time constant");
   }
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const intptr_t expr_pos = TokenPos();
-  AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
+  AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kIFNULL));
   if (CurrentToken() == Token::kCONDITIONAL) {
     EnsureExpressionTemp();
     ConsumeToken();
     AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
     expr = new(Z) ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
@@ skipping 186 matching lines @@
                                    arguments->NodeAt(0),
                                    arguments->NodeAt(1));
     }
   }
   return new(Z) StaticCallNode(ident_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver,
                                    const String& func_name,
-                                   intptr_t ident_pos) {
+                                   intptr_t ident_pos,
+                                   bool is_conditional) {
   TRACE_PARSER("ParseInstanceCall");
   CheckToken(Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
-  return new(Z) InstanceCallNode(ident_pos, receiver, func_name, arguments);
+  return new(Z) InstanceCallNode(ident_pos,
+                                 receiver,
+                                 func_name,
+                                 arguments,
+                                 is_conditional);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return BuildClosureCall(call_pos, closure, arguments);
 }
@@ skipping 125 matching lines @@
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
-    if (CurrentToken() == Token::kPERIOD) {
+    if ((CurrentToken() == Token::kPERIOD) ||
+        (CurrentToken() == Token::kQM_PERIOD)) {
+      // Unconditional or conditional property extraction or method call.
+      bool is_conditional = CurrentToken() == Token::kQM_PERIOD;
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary_node = left->AsPrimaryNode();
         const intptr_t primary_pos = primary_node->token_pos();
         if (primary_node->primary().IsFunction()) {
           left = LoadClosure(primary_node);
         } else if (primary_node->primary().IsTypeParameter()) {
           if (ParsingStaticMember()) {
-            const String& name = String::ZoneHandle(Z,
+            const String& name = String::Handle(Z,
                 TypeParameter::Cast(primary_node->primary()).name());
             ReportError(primary_pos,
                         "cannot access type parameter '%s' "
                         "from static function",
                         name.ToCString());
           }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
               TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
           left = new(Z) TypeNode(primary->token_pos(), type_parameter);
+        } else if (is_conditional && primary_node->primary().IsClass()) {
+          // The left-hand side of ?. is interpreted as an expression
+          // of type Type, not as a class literal.
+          const Class& type_class = Class::Cast(primary_node->primary());
+          AbstractType& type = Type::ZoneHandle(Z,
+              Type::New(type_class, TypeArguments::Handle(Z),
+              primary_pos, Heap::kOld));
+          type ^= ClassFinalizer::FinalizeType(
+              current_class(), type, ClassFinalizer::kCanonicalize);
+          // Type may be malbounded, but not malformed.
+          ASSERT(!type.IsMalformed());
+          left = new(Z) TypeNode(primary_pos, type);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
           ASSERT(!primary_node->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const intptr_t ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         // Identifier followed by a opening paren: method call.
         if (left->IsPrimaryNode() &&
             left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
+          ASSERT(!is_conditional);
           const Class& cls = Class::Cast(left->AsPrimaryNode()->primary());
           selector = ParseStaticCall(cls, *ident, ident_pos);
         } else {
-          selector = ParseInstanceCall(left, *ident, ident_pos);
+          selector = ParseInstanceCall(left, *ident, ident_pos, is_conditional);
         }
       } else {
         // Field access.
         Class& cls = Class::Handle(Z);
         bool is_deferred = false;
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           if (primary_node->primary().IsClass()) {
             // If the primary node referred to a class we are loading a
             // qualified static field.
             cls ^= primary_node->primary().raw();
             is_deferred = primary_node->is_deferred_reference();
           }
         }
         if (cls.IsNull()) {
           // Instance field access.
-          selector = CallGetter(ident_pos, left, *ident);
+          selector = new(Z) InstanceGetterNode(ident_pos,
+                                               left,
+                                               *ident,
+                                               is_conditional);
         } else {
           // Static field access.
+          ASSERT(!is_conditional);
           selector = GenerateStaticFieldAccess(cls, *ident, ident_pos);
           ASSERT(selector != NULL);
           if (selector->IsLoadStaticFieldNode()) {
             selector->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
           } else if (selector->IsStaticGetterNode()) {
             selector->AsStaticGetterNode()->set_is_deferred(is_deferred);
           }
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
@@ skipping 63 matching lines @@
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ReportError(primary_pos,
                           "cannot access instance method '%s' "
                           "from static function",
                           func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos),
                                          func_name,
-                                         primary_pos);
+                                         primary_pos,
+                                         false /* is_conditional */);
           }
         } else if (primary_node->primary().IsString()) {
           // Primary is an unresolved name.
           if (primary_node->IsSuper()) {
             ReportError(primary_pos, "illegal use of super");
           }
           String& name =
               String::CheckedZoneHandle(primary_node->primary().raw());
           if (current_function().is_static()) {
             // The static call will be converted to throwing a NSM error.
             selector = ParseStaticCall(current_class(), name, primary_pos);
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos),
                                          name,
-                                         primary_pos);
+                                         primary_pos,
+                                         false /* is_conditional */);
           }
         } else if (primary_node->primary().IsTypeParameter()) {
           const String& name = String::ZoneHandle(Z,
               TypeParameter::Cast(primary_node->primary()).name());
           if (ParsingStaticMember()) {
             // Treat as this.T(), because T is in scope.
             ReportError(primary_pos,
                         "cannot access type parameter '%s' "
                         "from static function",
                         name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             selector = ParseInstanceCall(LoadReceiver(primary_pos),
                                          name,
-                                         primary_pos);
+                                         primary_pos,
+                                         false /* is_conditional */);
           }
         } else if (primary_node->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Z, Type::New(
               type_class, TypeArguments::Handle(Z), primary_pos));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
           selector = new(Z) TypeNode(primary_pos, type);
@@ skipping 1901 matching lines @@
       const String& ident = *ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         primary = ParseSuperCall(ident);
       } else {
         primary = ParseSuperFieldAccess(ident, ident_pos);
       }
     } else if ((CurrentToken() == Token::kLBRACK) ||
         Token::CanBeOverloaded(CurrentToken()) ||
         (CurrentToken() == Token::kNE)) {
       primary = ParseSuperOperator();
+    } else if (CurrentToken() == Token::kQM_PERIOD) {
+      ReportError("super call or super getter may not use ?.");
     } else {
       primary = new(Z) PrimaryNode(super_pos, Symbols::Super());
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
 
@@ skipping 266 matching lines @@
 void Parser::SkipSelectors() {
   while (true) {
     const Token::Kind current_token = CurrentToken();
     if (current_token == Token::kCASCADE) {
       ConsumeToken();
       if (CurrentToken() == Token::kLBRACK) {
         continue;  // Consume [ in next loop iteration.
       } else {
         ExpectIdentifier("identifier or [ expected after ..");
       }
-    } else if (current_token == Token::kPERIOD) {
+    } else if ((current_token == Token::kPERIOD) ||
+        (current_token == Token::kQM_PERIOD)) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
     } else if (current_token == Token::kLBRACK) {
       ConsumeToken();
       SkipNestedExpr();
       ExpectToken(Token::kRBRACK);
     } else if (current_token == Token::kLPAREN) {
       SkipActualParameters();
     } else {
       break;
@@ skipping 17 matching lines @@
     ConsumeToken();
     SkipUnaryExpr();
   } else {
     SkipPostfixExpr();
   }
 }
 
 
 void Parser::SkipBinaryExpr() {
   SkipUnaryExpr();
-  const int min_prec = Token::Precedence(Token::kOR);
+  const int min_prec = Token::Precedence(Token::kIFNULL);
   const int max_prec = Token::Precedence(Token::kMUL);
   while (((min_prec <= Token::Precedence(CurrentToken())) &&
       (Token::Precedence(CurrentToken()) <= max_prec))) {
     if (CurrentToken() == Token::kIS) {
       ConsumeToken();
       if (CurrentToken() == Token::kNOT) {
         ConsumeToken();
       }
       SkipType(false);
     } else if (CurrentToken() == Token::kAS) {
@@ skipping 43 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart