Implement new optional parameters syntax in the vm (issue 4290).

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 125 matching lines @@
             String::Handle(Symbols::SavedArgDescVarPrefix()))) {
       return saved_args_desc_var;
     }
   }
   return NULL;
 }
 
 
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
-  const int fixed_parameter_count = function().num_fixed_parameters();
-  const int optional_parameter_count = function().num_optional_parameters();
-  int parameter_count = fixed_parameter_count + optional_parameter_count;
+  const intptr_t num_fixed_params = function().num_fixed_parameters();
+  const intptr_t num_opt_pos_params =
+      function().num_optional_positional_parameters();
+  const intptr_t num_opt_named_params =
+      function().num_optional_named_parameters();
+  const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
+  intptr_t num_params = num_fixed_params + num_opt_params;
   const bool is_native_instance_closure =
       function().is_native() && function().IsImplicitInstanceClosureFunction();
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
-  if ((optional_parameter_count == 0) && !is_native_instance_closure) {
-    // Parameter i will be at fp[1 + parameter_count - i] and local variable
+  if ((num_opt_params == 0) && !is_native_instance_closure) {
+    // Parameter i will be at fp[1 + num_params - i] and local variable
     // j will be at fp[kFirstLocalSlotIndex - j].
     ASSERT(GetSavedArgumentsDescriptorVar() == NULL);
-    first_parameter_index_ = 1 + parameter_count;
+    first_parameter_index_ = 1 + num_params;
     first_stack_local_index_ = kFirstLocalSlotIndex;
-    copied_parameter_count_ = 0;
+    num_copied_params_ = 0;
   } else {
     // Parameter i will be at fp[kFirstLocalSlotIndex - i] and local variable
-    // j will be at fp[kFirstLocalSlotIndex - parameter_count - j].
+    // j will be at fp[kFirstLocalSlotIndex - num_params - j].
     // The saved argument descriptor variable must be allocated similarly to
     // a parameter, so that it gets both a frame slot and a context slot when
     // captured.
     if (GetSavedArgumentsDescriptorVar() != NULL) {
-      parameter_count += 1;
+      num_params += 1;
     }
     first_parameter_index_ = kFirstLocalSlotIndex;
-    first_stack_local_index_ = first_parameter_index_ - parameter_count;
-    copied_parameter_count_ = parameter_count;
+    first_stack_local_index_ = first_parameter_index_ - num_params;
+    num_copied_params_ = num_params;
     if (is_native_instance_closure) {
-      copied_parameter_count_ += 1;
+      num_copied_params_ += 1;
       first_parameter_index_ -= 1;
       first_stack_local_index_ -= 1;
     }
   }
 
   // Allocate parameters and local variables, either in the local frame or
   // in the context(s).
   LocalScope* context_owner = NULL;  // No context needed yet.
   int next_free_frame_index =
       scope->AllocateVariables(first_parameter_index_,
-                               parameter_count,
+                               num_params,
                                first_stack_local_index_,
                                scope,
                                &context_owner);
 
   // If this function is not a closure function and if it contains captured
   // variables, the context needs to be saved on entry and restored on exit.
   // Add and allocate a local variable to this purpose.
   if ((context_owner != NULL) && !function().IsClosureFunction()) {
     const String& context_var_name =
         String::ZoneHandle(Symbols::SavedEntryContextVar());
     LocalVariable* context_var =
         new LocalVariable(function().token_pos(),
                           context_var_name,
                           Type::ZoneHandle(Type::DynamicType()));
     context_var->set_index(next_free_frame_index--);
     scope->AddVariable(context_var);
     set_saved_context_var(context_var);
   }
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
-  stack_local_count_ = first_stack_local_index_ - next_free_frame_index;
+  num_stack_locals_ = first_stack_local_index_ - next_free_frame_index;
 }
 
 
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
     : parent(outer_block), scope(local_scope), statements(seq) {
     ASSERT(scope != NULL);
     ASSERT(statements != NULL);
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
@@ skipping 203 matching lines @@
 
 
 struct ParamList {
   ParamList() {
     Clear();
   }
 
   void Clear() {
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
-    has_named_optional_parameters = false;
+    has_optional_positional_parameters = false;
+    has_optional_named_parameters = false;
     has_field_initializer = false;
     implicitly_final = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
   void AddFinalParameter(intptr_t name_pos,
                          String* name,
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
@@ skipping 10 matching lines @@
                       &String::ZoneHandle(Symbols::This()),
                       receiver_type);
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
-  bool has_named_optional_parameters;  // Indicates use of the new syntax.
+  bool has_optional_positional_parameters;
+  bool has_optional_named_parameters;
   bool has_field_initializer;
   bool implicitly_final;
   ZoneGrowableArray<ParamDesc>* parameters;
 };
 
 
 struct MemberDesc {
   MemberDesc() {
     Clear();
   }
@@ skipping 294 matching lines @@
 
 // TODO(regis): Implement support for non-const final static fields (currently
 // supported "final" fields are actually const fields).
 // TODO(regis): Since a const variable is implicitly final,
 // rename ParseStaticConstGetter to ParseStaticFinalGetter and
 // rename kConstImplicitGetter to kImplicitFinalGetter.
 SequenceNode* Parser::ParseStaticConstGetter(const Function& func) {
   TRACE_PARSER("ParseStaticConstGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
-  ASSERT(func.num_optional_parameters() == 0);
+  ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupStaticField(field_name));
@@ skipping 95 matching lines @@
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
-  ASSERT(func.num_optional_parameters() == 0);
+  ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(TokenPos(), receiver);
   // TokenPos() returns the function's token position which points to the
@@ skipping 28 matching lines @@
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
   const AbstractType& field_type = AbstractType::ZoneHandle(field.type());
 
   ParamList params;
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(TokenPos()));
   params.AddFinalParameter(TokenPos(),
                            &String::ZoneHandle(Symbols::Value()),
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
-  ASSERT(func.num_optional_parameters() == 0);
+  ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
       new LoadLocalNode(TokenPos(), current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
       new LoadLocalNode(TokenPos(), current_block_->scope->VariableAt(1));
@@ skipping 180 matching lines @@
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         signature_type ^= ClassFinalizer::FinalizeType(
             signature_class, signature_type, ClassFinalizer::kCanonicalize);
       }
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
-  if (CurrentToken() == Token::kASSIGN) {
-    if (!params->has_named_optional_parameters ||
+  if ((CurrentToken() == Token::kASSIGN) || (CurrentToken() == Token::kCOLON)) {
+    if ((!params->has_optional_positional_parameters &&
+         !params->has_optional_named_parameters) ||
         !allow_explicit_default_value) {
       ErrorMsg("parameter must not specify a default value");
     }
-    ConsumeToken();
+    if (params->has_optional_positional_parameters) {
+      ExpectToken(Token::kASSIGN);
+    } else {
+      ExpectToken(Token::kCOLON);
+    }
     params->num_optional_parameters++;
     if (is_top_level_) {
       // Skip default value parsing.
       SkipExpr();
     } else {
       const Object& const_value = ParseConstExpr()->literal();
       parameter.default_value = &const_value;
     }
   } else {
-    if (params->has_named_optional_parameters) {
+    if (params->has_optional_positional_parameters ||
+        params->has_optional_named_parameters) {
       // Implicit default value is null.
       params->num_optional_parameters++;
       parameter.default_value = &Object::ZoneHandle();
     } else {
       params->num_fixed_parameters++;
       ASSERT(params->num_optional_parameters == 0);
     }
   }
   if (parameter.type->IsVoidType()) {
     ErrorMsg("parameter '%s' may not be 'void'", parameter.name->ToCString());
   }
   params->parameters->Add(parameter);
 }
 
 
 void Parser::ParseFormalParameterList(bool allow_explicit_default_values,
                                       ParamList* params) {
   TRACE_PARSER("ParseFormalParameterList");
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   if (LookaheadToken(1) != Token::kRPAREN) {
-    // Parse positional parameters.
+    // Parse fixed parameters.
     ParseFormalParameters(allow_explicit_default_values, params);
-    if (params->has_named_optional_parameters) {
-      // Parse named optional parameters.
+    if (params->has_optional_positional_parameters ||
+        params->has_optional_named_parameters) {
+      // Parse optional parameters.
       ParseFormalParameters(allow_explicit_default_values, params);
-      if (CurrentToken() != Token::kRBRACK) {
-        ErrorMsg("',' or ']' expected");
+      if (params->has_optional_positional_parameters) {
+        if (CurrentToken() != Token::kRBRACK) {
+          ErrorMsg("',' or ']' expected");
+        }
+      } else {
+        if (CurrentToken() != Token::kRBRACE) {
+          ErrorMsg("',' or '}' expected");
+        }
       }
-      ExpectToken(Token::kRBRACK);
+      ConsumeToken();  // ']' or '}'.
     }
     if ((CurrentToken() != Token::kRPAREN) &&
-        !params->has_named_optional_parameters) {
+        !params->has_optional_positional_parameters &&
+        !params->has_optional_named_parameters) {
       ErrorMsg("',' or ')' expected");
     }
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
 }
 
 
-// Parses a sequence of normal or named formal parameters.
+// Parses a sequence of normal or optional formal parameters.
 void Parser::ParseFormalParameters(bool allow_explicit_default_values,
                                    ParamList* params) {
   TRACE_PARSER("ParseFormalParameters");
   do {
     ConsumeToken();
-    if (!params->has_named_optional_parameters &&
+    if (!params->has_optional_positional_parameters &&
+        !params->has_optional_named_parameters &&
         (CurrentToken() == Token::kLBRACK)) {
-      // End of normal parameters, start of named parameters.
-      params->has_named_optional_parameters = true;
+      // End of normal parameters, start of optional positional parameters.
+      params->has_optional_positional_parameters = true;
+      return;
+    }
+    if (!params->has_optional_positional_parameters &&
+        !params->has_optional_named_parameters &&
+        (CurrentToken() == Token::kLBRACE)) {
+      // End of normal parameters, start of optional named parameters.
+      params->has_optional_named_parameters = true;
       return;
     }
     ParseFormalParameter(allow_explicit_default_values, params);
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 String& Parser::ParseNativeDeclaration() {
   TRACE_PARSER("ParseNativeDeclaration");
   ASSERT(IsLiteral("native"));
@@ skipping 1521 matching lines @@
       expected_num_parameters = 2;
     }
   } else if ((operator_token == Token::kNEGATE) ||
       (operator_token == Token::kBIT_NOT)) {
     // TODO(hausner): Remove support for keyword 'negate'.
     expected_num_parameters = 1;
   } else {
     expected_num_parameters = 2;
   }
   if ((member.params.num_optional_parameters > 0) ||
-      (member.params.has_named_optional_parameters) ||
+      member.params.has_optional_positional_parameters ||
+      member.params.has_optional_named_parameters ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
     ErrorMsg(member.name_pos, "operator %s expects %"Pd" argument(s)",
         member.name->ToCString(), (expected_num_parameters - 1));
   }
 }
 
 
 void Parser::ParseClassMemberDefinition(ClassDesc* members) {
   TRACE_PARSER("ParseClassMemberDefinition");
@@ skipping 1510 matching lines @@
     }
   }
 }
 
 
 // Populate the parameter type array and parameter name array of the function
 // with the formal parameter types and names.
 void Parser::AddFormalParamsToFunction(const ParamList* params,
                                        const Function& func) {
   ASSERT((params != NULL) && (params->parameters != NULL));
-  func.set_num_fixed_parameters(params->num_fixed_parameters);
-  func.set_num_optional_parameters(params->num_optional_parameters);
+  ASSERT((params->num_optional_parameters > 0) ==
+         (params->has_optional_positional_parameters ||
+          params->has_optional_named_parameters));
+  func.SetNumberOfParameters(params->num_fixed_parameters,
+                             params->num_optional_parameters,
+                             params->has_optional_positional_parameters);
   const int num_parameters = params->parameters->length();
   ASSERT(num_parameters == func.NumberOfParameters());
   func.set_parameter_types(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
   func.set_parameter_names(Array::Handle(Array::New(num_parameters,
                                                     Heap::kOld)));
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(is_top_level_ || param_desc.type->IsResolved());
     func.SetParameterTypeAt(i, *param_desc.type);
@@ skipping 5110 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart