Remove --reject_named_argument_as_positional flag from the VM.

runtime/vm/flow_graph_compiler_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
 #include "vm/ast_printer.h"
 #include "vm/il_printer.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_ast);
 DECLARE_FLAG(bool, print_scopes);
-DECLARE_FLAG(bool, reject_named_argument_as_positional);
 DECLARE_FLAG(bool, trace_functions);
 DECLARE_FLAG(bool, use_sse41);
 DEFINE_FLAG(bool, trap_on_deoptimization, false, "Trap on deoptimization.");
 
 
 FieldAddress FlowGraphCompiler::ElementAddressForRegIndex(intptr_t cid,
                                                           Register array,
                                                           Register index) {
   // Note that index is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
@@ skipping 657 matching lines @@
   const Address argument_addr(RBX, RCX, TIMES_8, 0);
   const Address copy_addr(RDI, RCX, TIMES_8, 0);
   __ Bind(&loop);
   __ movq(RAX, argument_addr);
   __ movq(copy_addr, RAX);
   __ Bind(&loop_condition);
   __ decq(RCX);
   __ j(POSITIVE, &loop, Assembler::kNearJump);
 
   // Copy or initialize optional named arguments.
-
-  if (!FLAG_reject_named_argument_as_positional) {
-    // Treat optional positional parameters as optional named parameters.
-    num_opt_named_params += num_opt_pos_params;
-  }
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label all_arguments_processed;
   if (num_opt_named_params > 0) {
     // Start by alphabetically sorting the names of the optional parameters.
     LocalVariable** opt_param = new LocalVariable*[num_opt_named_params];
     int* opt_param_position = new int[num_opt_named_params];
     for (int pos = num_fixed_params; pos < num_params; pos++) {
       LocalVariable* parameter = scope->VariableAt(pos);
       const String& opt_param_name = parameter->name();
@@ skipping 15 matching lines @@
     // Number of positional args is the second Smi in descriptor array (R10).
     __ movq(RCX, FieldAddress(R10, Array::data_offset() + (1 * kWordSize)));
     __ SmiUntag(RCX);
     // Let RBX point to the first passed argument, i.e. to fp[1 + argc - 0].
     __ leaq(RBX, Address(RBP, RBX, TIMES_4, kWordSize));  // RBX is Smi.
     // Let EDI point to the name/pos pair of the first named argument.
     __ leaq(RDI, FieldAddress(R10, Array::data_offset() + (2 * kWordSize)));
     for (int i = 0; i < num_opt_named_params; i++) {
       Label load_default_value, assign_optional_parameter, next_parameter;
       const int param_pos = opt_param_position[i];
-      if (!FLAG_reject_named_argument_as_positional) {
-        // Handle this optional parameter only if k or fewer positional
-        // arguments have been passed, where k is the position of this optional
-        // parameter in the formal parameter list.
-        __ cmpq(RCX, Immediate(param_pos));
-        __ j(GREATER, &next_parameter, Assembler::kNearJump);
-      }
       // Check if this named parameter was passed in.
       __ movq(RAX, Address(RDI, 0));  // Load RAX with the name of the argument.
       ASSERT(opt_param[i]->name().IsSymbol());
       __ CompareObject(RAX, opt_param[i]->name());
       __ j(NOT_EQUAL, &load_default_value, Assembler::kNearJump);
       // Load RAX with passed-in argument at provided arg_pos, i.e. at
       // fp[1 + argc - arg_pos].
       __ movq(RAX, Address(RDI, kWordSize));  // RAX is arg_pos as Smi.
       __ addq(RDI, Immediate(2 * kWordSize));  // Point to next name/pos pair.
       __ negq(RAX);
@@ skipping 16 matching lines @@
       const Address param_addr(RBP, (computed_param_pos * kWordSize));
       __ movq(param_addr, RAX);
       __ Bind(&next_parameter);
     }
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that RDI now points to the null terminator in the array descriptor.
     __ cmpq(Address(RDI, 0), raw_null);
     __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
   } else if (num_opt_pos_params > 0) {
-    ASSERT(FLAG_reject_named_argument_as_positional);
     // Number of positional args is the second Smi in descriptor array (R10).
     __ movq(RCX, FieldAddress(R10, Array::data_offset() + (1 * kWordSize)));
     __ SmiUntag(RCX);
     for (int i = 0; i < num_opt_pos_params; i++) {
       Label next_parameter;
       // Handle this optional positonal parameter only if k or fewer positional
       // arguments have been passed, where k is param_pos, the position of this
       // optional parameter in the formal parameter list.
       const int param_pos = num_fixed_params + i;
       __ cmpq(RCX, Immediate(param_pos));
@@ skipping 582 matching lines @@
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   __ Exchange(mem1, mem2);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64