Remove --reject_named_argument_as_positional flag from the VM.

runtime/vm/flow_graph_compiler_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #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);
 DEFINE_FLAG(bool, trap_on_deoptimization, false, "Trap on deoptimization.");
 DEFINE_FLAG(bool, unbox_mints, true, "Optimize 64-bit integer arithmetic.");
 
 
 FieldAddress FlowGraphCompiler::ElementAddressForRegIndex(intptr_t cid,
                                                           Register array,
                                                           Register index) {
   // Note that index is Smi, i.e, times 2.
   ASSERT(kSmiTagShift == 1);
@@ skipping 654 matching lines @@
   const Address argument_addr(EBX, ECX, TIMES_4, 0);
   const Address copy_addr(EDI, ECX, TIMES_4, 0);
   __ Bind(&loop);
   __ movl(EAX, argument_addr);
   __ movl(copy_addr, EAX);
   __ Bind(&loop_condition);
   __ decl(ECX);
   __ 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 (EDX).
     __ movl(ECX, FieldAddress(EDX, Array::data_offset() + (1 * kWordSize)));
     __ SmiUntag(ECX);
     // Let EBX point to the first passed argument, i.e. to fp[1 + argc - 0].
     __ leal(EBX, Address(EBP, EBX, TIMES_2, kWordSize));  // EBX is Smi.
     // Let EDI point to the name/pos pair of the first named argument.
     __ leal(EDI, FieldAddress(EDX, 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.
-        __ cmpl(ECX, Immediate(param_pos));
-        __ j(GREATER, &next_parameter, Assembler::kNearJump);
-      }
       // Check if this named parameter was passed in.
       __ movl(EAX, Address(EDI, 0));  // Load EAX with the name of the argument.
       ASSERT(opt_param[i]->name().IsSymbol());
       __ CompareObject(EAX, opt_param[i]->name());
       __ j(NOT_EQUAL, &load_default_value, Assembler::kNearJump);
       // Load EAX with passed-in argument at provided arg_pos, i.e. at
       // fp[1 + argc - arg_pos].
       __ movl(EAX, Address(EDI, kWordSize));  // EAX is arg_pos as Smi.
       __ addl(EDI, Immediate(2 * kWordSize));  // Point to next name/pos pair.
       __ negl(EAX);
@@ skipping 16 matching lines @@
       const Address param_addr(EBP, (computed_param_pos * kWordSize));
       __ movl(param_addr, EAX);
       __ Bind(&next_parameter);
     }
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that EDI now points to the null terminator in the array descriptor.
     __ cmpl(Address(EDI, 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 (EDX).
     __ movl(ECX, FieldAddress(EDX, Array::data_offset() + (1 * kWordSize)));
     __ SmiUntag(ECX);
     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;
       __ cmpl(ECX, Immediate(param_pos));
@@ skipping 606 matching lines @@
   __ popl(ECX);
   __ popl(EAX);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32