Remove --reject_named_argument_as_positional flag from the VM.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 19 matching lines @@
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, generate_gdb_symbols, false,
     "Generate symbols of generated dart functions for debugging with GDB");
-DEFINE_FLAG(bool, reject_named_argument_as_positional, true,
-    "Enforce new rules for optional parameters and disallow passing of named "
-    "arguments to optional positional formal parameters");
 DEFINE_FLAG(bool, show_internal_names, false,
     "Show names of internal classes (e.g. \"OneByteString\") in error messages "
     "instead of showing the corresponding interface names (e.g. \"String\")");
 DEFINE_FLAG(bool, trace_disabling_optimized_code, false,
     "Trace disabling optimized code.");
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 
 static const char* kGetterPrefix = "get:";
@@ skipping 3362 matching lines @@
     // marked as non-static, but they do not have a receiver.
     return 1;  // Receiver.
   }
   return 0;  // No implicit parameters.
 }
 
 
 bool Function::AreValidArgumentCounts(int num_arguments,
                                       int num_named_arguments,
                                       String* error_message) const {
-  if (FLAG_reject_named_argument_as_positional) {
-    if (num_named_arguments > NumOptionalNamedParameters()) {
-      if (error_message != NULL) {
-        const intptr_t kMessageBufferSize = 64;
-        char message_buffer[kMessageBufferSize];
-        OS::SNPrint(message_buffer,
-                    kMessageBufferSize,
-                    "%d named passed, at most %"Pd" expected",
-                    num_named_arguments,
-                    NumOptionalNamedParameters());
-        *error_message = String::New(message_buffer);
-      }
-      return false;  // Too many named arguments.
-    }
-    const int num_pos_args = num_arguments - num_named_arguments;
-    const int num_opt_pos_params = NumOptionalPositionalParameters();
-    const int num_pos_params = num_fixed_parameters() + num_opt_pos_params;
-    if (num_pos_args > num_pos_params) {
-      if (error_message != NULL) {
-        const intptr_t kMessageBufferSize = 64;
-        char message_buffer[kMessageBufferSize];
-        // Hide implicit parameters to the user.
-        const intptr_t num_hidden_params = NumImplicitParameters();
-        OS::SNPrint(message_buffer,
-                    kMessageBufferSize,
-                    "%"Pd"%s passed, %s%"Pd" expected",
-                    num_pos_args - num_hidden_params,
-                    num_opt_pos_params > 0 ? " positional" : "",
-                    num_opt_pos_params > 0 ? "at most " : "",
-                    num_pos_params - num_hidden_params);
-        *error_message = String::New(message_buffer);
-      }
-      return false;  // Too many fixed and/or positional arguments.
-    }
-    if (num_pos_args < num_fixed_parameters()) {
-      if (error_message != NULL) {
-        const intptr_t kMessageBufferSize = 64;
-        char message_buffer[kMessageBufferSize];
-        // Hide implicit parameters to the user.
-        const intptr_t num_hidden_params = NumImplicitParameters();
-        OS::SNPrint(message_buffer,
-                    kMessageBufferSize,
-                    "%"Pd"%s passed, %s%"Pd" expected",
-                    num_pos_args - num_hidden_params,
-                    num_opt_pos_params > 0 ? " positional" : "",
-                    num_opt_pos_params > 0 ? "at least " : "",
-                    num_fixed_parameters() - num_hidden_params);
-        *error_message = String::New(message_buffer);
-      }
-      return false;  // Too few fixed and/or positional arguments.
-    }
-    return true;
-  }
-
-  // TODO(regis): Remove the following code once the flag is removed.
-
-  if (num_arguments > NumParameters()) {
+  if (num_named_arguments > NumOptionalNamedParameters()) {
     if (error_message != NULL) {
       const intptr_t kMessageBufferSize = 64;
       char message_buffer[kMessageBufferSize];
+      OS::SNPrint(message_buffer,
+                  kMessageBufferSize,
+                  "%d named passed, at most %"Pd" expected",
+                  num_named_arguments,
+                  NumOptionalNamedParameters());
+      *error_message = String::New(message_buffer);
+    }
+    return false;  // Too many named arguments.
+  }
+  const int num_pos_args = num_arguments - num_named_arguments;
+  const int num_opt_pos_params = NumOptionalPositionalParameters();
+  const int num_pos_params = num_fixed_parameters() + num_opt_pos_params;
+  if (num_pos_args > num_pos_params) {
+    if (error_message != NULL) {
+      const intptr_t kMessageBufferSize = 64;
+      char message_buffer[kMessageBufferSize];
       // Hide implicit parameters to the user.
       const intptr_t num_hidden_params = NumImplicitParameters();
       OS::SNPrint(message_buffer,
                   kMessageBufferSize,
-                  "%"Pd" passed, %s%"Pd" expected",
-                  num_arguments - num_hidden_params,
-                  HasOptionalParameters() ? "at most " : "",
-                  NumParameters() - num_hidden_params);
+                  "%"Pd"%s passed, %s%"Pd" expected",
+                  num_pos_args - num_hidden_params,
+                  num_opt_pos_params > 0 ? " positional" : "",
+                  num_opt_pos_params > 0 ? "at most " : "",
+                  num_pos_params - num_hidden_params);
       *error_message = String::New(message_buffer);
     }
-    return false;  // Too many arguments.
+    return false;  // Too many fixed and/or positional arguments.
   }
-  const int num_positional_args = num_arguments - num_named_arguments;
-  if (num_positional_args < num_fixed_parameters()) {
+  if (num_pos_args < num_fixed_parameters()) {
     if (error_message != NULL) {
       const intptr_t kMessageBufferSize = 64;
       char message_buffer[kMessageBufferSize];
       // Hide implicit parameters to the user.
       const intptr_t num_hidden_params = NumImplicitParameters();
       OS::SNPrint(message_buffer,
                   kMessageBufferSize,
-                  "%"Pd" %spassed, %"Pd" expected",
-                  num_positional_args - num_hidden_params,
-                  HasOptionalParameters() ? "positional " : "",
+                  "%"Pd"%s passed, %s%"Pd" expected",
+                  num_pos_args - num_hidden_params,
+                  num_opt_pos_params > 0 ? " positional" : "",
+                  num_opt_pos_params > 0 ? "at least " : "",
                   num_fixed_parameters() - num_hidden_params);
       *error_message = String::New(message_buffer);
     }
-    return false;  // Too few arguments.
+    return false;  // Too few fixed and/or positional arguments.
   }
   return true;
 }
 
 
 bool Function::AreValidArguments(int num_arguments,
                                  const Array& argument_names,
                                  String* error_message) const {
   const int num_named_arguments =
       argument_names.IsNull() ? 0 : argument_names.Length();
@@ skipping 95 matching lines @@
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_pos_params =
       other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
       other.NumOptionalNamedParameters();
   // A generative constructor may be compared to a redirecting factory and be
   // compatible although it has an additional phase parameter.
   const intptr_t num_ignored_params =
       (other.IsRedirectingFactory() && IsConstructor()) ? 1 : 0;
-  if (FLAG_reject_named_argument_as_positional) {
-    // The default values of optional parameters can differ.
-    if (((num_fixed_params - num_ignored_params) != other_num_fixed_params) ||
-        (num_opt_pos_params < other_num_opt_pos_params) ||
-        (num_opt_named_params < other_num_opt_named_params)) {
-      return false;
-    }
-    if (other_num_opt_named_params == 0) {
-      return true;
-    }
-    // Check that for each optional named parameter of the other function there
-    // exists an optional named parameter of this function with an identical
-    // name.
-    // Note that SetParameterNameAt() guarantees that names are symbols, so we
-    // can compare their raw pointers.
-    const int num_params = num_fixed_params + num_opt_named_params;
-    const int other_num_params =
-        other_num_fixed_params + other_num_opt_named_params;
-    bool found_param_name;
-    String& other_param_name = String::Handle();
-    for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
-      other_param_name = other.ParameterNameAt(i);
-      found_param_name = false;
-      for (intptr_t j = num_fixed_params; j < num_params; j++) {
-        if (ParameterNameAt(j) == other_param_name.raw()) {
-          found_param_name = true;
-          break;
-        }
-      }
-      if (!found_param_name) {
-        return false;
+  // The default values of optional parameters can differ.
+  if (((num_fixed_params - num_ignored_params) != other_num_fixed_params) ||
+      (num_opt_pos_params < other_num_opt_pos_params) ||
+      (num_opt_named_params < other_num_opt_named_params)) {
+    return false;
+  }
+  if (other_num_opt_named_params == 0) {
+    return true;
+  }
+  // Check that for each optional named parameter of the other function there
+  // exists an optional named parameter of this function with an identical
+  // name.
+  // Note that SetParameterNameAt() guarantees that names are symbols, so we
+  // can compare their raw pointers.
+  const int num_params = num_fixed_params + num_opt_named_params;
+  const int other_num_params =
+      other_num_fixed_params + other_num_opt_named_params;
+  bool found_param_name;
+  String& other_param_name = String::Handle();
+  for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
+    other_param_name = other.ParameterNameAt(i);
+    found_param_name = false;
+    for (intptr_t j = num_fixed_params; j < num_params; j++) {
+      if (ParameterNameAt(j) == other_param_name.raw()) {
+        found_param_name = true;
+        break;
       }
     }
-    return true;
-  }
-
-  // TODO(regis): Remove the following code once the flag is removed.
-
-  // The default values of optional parameters can differ.
-  const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
-  const intptr_t other_num_opt_params =
-      other_num_opt_pos_params + other_num_opt_named_params;
-  if (((num_fixed_params - num_ignored_params) != other_num_fixed_params) ||
-      (num_opt_params < other_num_opt_params)) {
-    return false;
-  }
-  // Check that for each optional named parameter of the other function there is
-  // a corresponding optional named parameter of this function with an identical
-  // name at the same position.
-  // Note that SetParameterNameAt() guarantees that names are symbols, so we can
-  // compare their raw pointers.
-  const int other_num_params = other_num_fixed_params + other_num_opt_params;
-  for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
-    const String& other_param_name = String::Handle(other.ParameterNameAt(i));
-    ASSERT(other_param_name.IsSymbol());
-    ASSERT(String::Handle(ParameterNameAt(i)).IsSymbol());
-    if (ParameterNameAt(i) != other_param_name.raw()) {
+    if (!found_param_name) {
       return false;
     }
   }
   return true;
 }
 
 
 // If test_kind == kIsSubtypeOf, checks if the type of the specified parameter
 // of this function is a subtype or a supertype of the type of the specified
 // parameter of the other function.
@@ skipping 77 matching lines @@
           !other_res_type.IsSubtypeOf(res_type, malformed_error)) {
         return false;
       }
     } else {
       ASSERT(test_kind == kIsMoreSpecificThan);
       if (!res_type.IsMoreSpecificThan(other_res_type, malformed_error)) {
         return false;
       }
     }
   }
-  if (FLAG_reject_named_argument_as_positional) {
-    // Check the types of fixed and optional positional parameters.
-    for (intptr_t i = 0; i < num_fixed_params + other_num_opt_pos_params; i++) {
-      if (!TestParameterType(test_kind,
-                             i, i, type_arguments, other, other_type_arguments,
-                             malformed_error)) {
-        return false;
-      }
-    }
-    // Check the names and types of optional named parameters.
-    if (other_num_opt_named_params == 0) {
-      return true;
-    }
-    // Check that for each optional named parameter of type T of the other
-    // function type, there exists an optional named parameter of this function
-    // type with an identical name and with a type S that is a either a subtype
-    // or supertype of T (if test_kind == kIsSubtypeOf) or that is more specific
-    // than T (if test_kind == kIsMoreSpecificThan).
-    // Note that SetParameterNameAt() guarantees that names are symbols, so we
-    // can compare their raw pointers.
-    const int num_params = num_fixed_params + num_opt_named_params;
-    const int other_num_params =
-        other_num_fixed_params + other_num_opt_named_params;
-    bool found_param_name;
-    String& other_param_name = String::Handle();
-    for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
-      other_param_name = other.ParameterNameAt(i);
-      ASSERT(other_param_name.IsSymbol());
-      found_param_name = false;
-      for (intptr_t j = num_fixed_params; j < num_params; j++) {
-        ASSERT(String::Handle(ParameterNameAt(j)).IsSymbol());
-        if (ParameterNameAt(j) == other_param_name.raw()) {
-          found_param_name = true;
-          if (!TestParameterType(test_kind,
-                                 j, i,
-                                 type_arguments, other, other_type_arguments,
-                                 malformed_error)) {
-            return false;
-          }
-          break;
-        }
-      }
-      if (!found_param_name) {
-        return false;
-      }
-    }
-  }
-
-  // TODO(regis): Remove the following code once the flag is removed.
-
-  // Check the types of fixed parameters.
-  for (intptr_t i = 0; i < num_fixed_params; i++) {
+  // Check the types of fixed and optional positional parameters.
+  for (intptr_t i = 0; i < num_fixed_params + other_num_opt_pos_params; i++) {
     if (!TestParameterType(test_kind,
                            i, i, type_arguments, other, other_type_arguments,
                            malformed_error)) {
       return false;
     }
   }
-  // Check the names and types of optional parameters.
+  // Check the names and types of optional named parameters.
+  if (other_num_opt_named_params == 0) {
+    return true;
+  }
   // Check that for each optional named parameter of type T of the other
-  // function type, there is a corresponding optional named parameter of this
-  // function at the same position with an identical name and with a type S
-  // that is a either a subtype or supertype of T (if test_kind == kIsSubtypeOf)
-  // or that is more specific than T (if test_kind == kIsMoreSpecificThan).
+  // function type, there exists an optional named parameter of this function
+  // type with an identical name and with a type S that is a either a subtype
+  // or supertype of T (if test_kind == kIsSubtypeOf) or that is more specific
+  // than T (if test_kind == kIsMoreSpecificThan).
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
-  const intptr_t other_num_params = other_num_fixed_params +
-      other_num_opt_pos_params + other_num_opt_named_params;
+  const int num_params = num_fixed_params + num_opt_named_params;
+  const int other_num_params =
+      other_num_fixed_params + other_num_opt_named_params;
+  bool found_param_name;
   String& other_param_name = String::Handle();
   for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     ASSERT(other_param_name.IsSymbol());
-    ASSERT(String::Handle(ParameterNameAt(i)).IsSymbol());
-    if ((ParameterNameAt(i) != other_param_name.raw()) ||
-        !TestParameterType(test_kind,
-                           i, i, type_arguments, other, other_type_arguments,
-                           malformed_error)) {
+    found_param_name = false;
+    for (intptr_t j = num_fixed_params; j < num_params; j++) {
+      ASSERT(String::Handle(ParameterNameAt(j)).IsSymbol());
+      if (ParameterNameAt(j) == other_param_name.raw()) {
+        found_param_name = true;
+        if (!TestParameterType(test_kind,
+                               j, i,
+                               type_arguments, other, other_type_arguments,
+                               malformed_error)) {
+          return false;
+        }
+        break;
+      }
+    }
+    if (!found_param_name) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::IsImplicitClosureFunction() const {
   if (!IsClosureFunction()) {
     return false;
@@ skipping 218 matching lines @@
   }
   if (num_opt_params > 0) {
     if (num_opt_pos_params > 0) {
       pieces.Add(kLBracket);
     } else {
       pieces.Add(kLBrace);
     }
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       // The parameter name of an optional positional parameter does not need
       // to be part of the signature, since it is not used.
-      if (!FLAG_reject_named_argument_as_positional ||
-          (num_opt_named_params > 0)) {
+      if (num_opt_named_params > 0) {
         name = ParameterNameAt(i);
         pieces.Add(name);
         pieces.Add(kColonSpace);
       }
       param_type = ParameterTypeAt(i);
       if (instantiate && !param_type.IsInstantiated()) {
         param_type = param_type.InstantiateFrom(instantiator);
       }
       ASSERT(!param_type.IsNull());
       name = param_type.BuildName(name_visibility);
@@ skipping 8152 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart