Limit the maximum number of formal parameters (32K fixed and 32K optional)

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 3917 matching lines @@
 }
 
 
 void Function::set_kind_tag(intptr_t value) const {
   raw_ptr()->kind_tag_ = value;
 }
 
 
 void Function::set_num_fixed_parameters(intptr_t value) const {
   ASSERT(value >= 0);
-  raw_ptr()->num_fixed_parameters_ = value;
+  ASSERT(Utils::IsInt(16, value));
+  raw_ptr()->num_fixed_parameters_ = static_cast<int16_t>(value);
 }
 
 
-void Function::set_num_optional_positional_parameters(intptr_t value) const {
-  ASSERT(value >= 0);
-  raw_ptr()->num_optional_positional_parameters_ = value;
-  // Optional positional and optional named parameters are mutually exclusive.
-  ASSERT((num_optional_positional_parameters() == 0) ||
-         (num_optional_named_parameters() == 0));
+void Function::set_num_optional_parameters(intptr_t value) const {
+  // A positive value indicates positional params, a negative one named params.
+  ASSERT(Utils::IsInt(16, value));
+  raw_ptr()->num_optional_parameters_ = static_cast<int16_t>(value);
 }
 
 
-void Function::set_num_optional_named_parameters(intptr_t value) const {
-  ASSERT(value >= 0);
-  raw_ptr()->num_optional_named_parameters_ = value;
-  // Optional positional and optional named parameters are mutually exclusive.
-  ASSERT((num_optional_positional_parameters() == 0) ||
-         (num_optional_named_parameters() == 0));
+void Function::SetNumOptionalParameters(intptr_t num_optional_parameters,
+                                        bool are_optional_positional) const {
+  ASSERT(num_optional_parameters >= 0);
+  set_num_optional_parameters(are_optional_positional ?
+                              num_optional_parameters :
+                              -num_optional_parameters);
 }
 
 
 bool Function::is_optimizable() const {
   return OptimizableBit::decode(raw_ptr()->kind_tag_) &&
          (script() != Script::null()) &&
          !is_native();
 }
 
 
@@ skipping 14 matching lines @@
   raw_ptr()->kind_tag_ = NativeBit::update(value, bits);
 }
 
 
 void Function::set_is_abstract(bool value) const {
   uword bits = raw_ptr()->kind_tag_;
   raw_ptr()->kind_tag_ = AbstractBit::update(value, bits);
 }
 
 
-intptr_t Function::NumberOfParameters() const {
-  return num_fixed_parameters() +
-      num_optional_positional_parameters() + num_optional_named_parameters();
+intptr_t Function::NumParameters() const {
+  return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
-intptr_t Function::NumberOfImplicitParameters() const {
+intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
     if (is_static()) {
       ASSERT(IsFactory());
       return 1;  // Type arguments.
     } else {
       ASSERT(IsConstructor());
       return 2;  // Instance, phase.
     }
   }
   if (!is_static() && (kind() != RawFunction::kClosureFunction)) {
     // Closure functions defined inside instance (i.e. non-static) functions are
     // marked as non-static, but they do not have a receiver.
     return 1;  // Receiver.
   }
   return 0;  // No implicit parameters.
 }
 
 
-void Function::SetNumberOfParameters(intptr_t num_fixed_parameters,
-                                     intptr_t num_optional_parameters,
-                                     bool are_optional_positional) const {
-  set_num_fixed_parameters(num_fixed_parameters);
-  if (are_optional_positional) {
-    set_num_optional_positional_parameters(num_optional_parameters);
-    set_num_optional_named_parameters(0);
-  } else {
-    set_num_optional_positional_parameters(0);
-    set_num_optional_named_parameters(num_optional_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 > num_optional_named_parameters()) {
+    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,
-                    num_optional_named_parameters());
+                    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 = num_optional_positional_parameters();
+    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 = NumberOfImplicitParameters();
+        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 = NumberOfImplicitParameters();
+        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 > NumberOfParameters()) {
+  if (num_arguments > NumParameters()) {
     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 = NumberOfImplicitParameters();
+      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 " : "",
-                  NumberOfParameters() - num_hidden_params);
+                  NumParameters() - num_hidden_params);
       *error_message = String::New(message_buffer);
     }
     return false;  // Too many arguments.
   }
   const int num_positional_args = num_arguments - num_named_arguments;
   if (num_positional_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 = NumberOfImplicitParameters();
+      const intptr_t num_hidden_params = NumImplicitParameters();
       OS::SNPrint(message_buffer,
                   kMessageBufferSize,
                   "%"Pd" %spassed, %"Pd" expected",
                   num_positional_args - num_hidden_params,
                   HasOptionalParameters() ? "positional " : "",
                   num_fixed_parameters() - num_hidden_params);
       *error_message = String::New(message_buffer);
     }
     return false;  // Too few arguments.
   }
@@ skipping 12 matching lines @@
     return false;
   }
   // Verify that all argument names are valid parameter names.
   String& argument_name = String::Handle();
   String& parameter_name = String::Handle();
   for (int i = 0; i < num_named_arguments; i++) {
     argument_name ^= argument_names.At(i);
     ASSERT(argument_name.IsSymbol());
     bool found = false;
     const int num_positional_args = num_arguments - num_named_arguments;
-    const int num_parameters = NumberOfParameters();
+    const int num_parameters = NumParameters();
     for (int j = num_positional_args; !found && (j < num_parameters); j++) {
       parameter_name ^= ParameterNameAt(j);
       ASSERT(argument_name.IsSymbol());
       if (argument_name.Equals(parameter_name)) {
         found = true;
       }
     }
     if (!found) {
       if (error_message != NULL) {
         const intptr_t kMessageBufferSize = 64;
@@ skipping 60 matching lines @@
 
 const char* Function::ToFullyQualifiedCString() const {
   char* chars = NULL;
   ConstructFunctionFullyQualifiedCString(*this, &chars, 0);
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
-  const intptr_t num_opt_pos_params = num_optional_positional_parameters();
-  const intptr_t num_opt_named_params = num_optional_named_parameters();
+  const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
+  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.num_optional_positional_parameters();
+      other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
-      other.num_optional_named_parameters();
+      other.NumOptionalNamedParameters();
   if (FLAG_reject_named_argument_as_positional) {
     // The default values of optional parameters can differ.
     if ((num_fixed_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;
     }
@@ skipping 97 matching lines @@
   return true;
 }
 
 
 bool Function::TypeTest(TypeTestKind test_kind,
                         const AbstractTypeArguments& type_arguments,
                         const Function& other,
                         const AbstractTypeArguments& other_type_arguments,
                         Error* malformed_error) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
-  const intptr_t num_opt_pos_params = num_optional_positional_parameters();
-  const intptr_t num_opt_named_params = num_optional_named_parameters();
+  const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
+  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.num_optional_positional_parameters();
+      other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
-      other.num_optional_named_parameters();
+      other.NumOptionalNamedParameters();
   if ((num_fixed_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;
   }
   // Check the result type.
   AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
     other_res_type = other_res_type.InstantiateFrom(other_type_arguments);
   }
@@ skipping 136 matching lines @@
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_is_abstract(is_abstract);
   result.set_is_external(is_external);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
-  result.set_num_optional_positional_parameters(0);
-  result.set_num_optional_named_parameters(0);
+  result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_is_optimizable(true);
   result.set_has_finally(false);
   result.set_is_native(false);
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
@@ skipping 38 matching lines @@
   }
   closure_function.set_context_scope(context_scope);
 
   // Set closure function's result type to this result type.
   closure_function.set_result_type(AbstractType::Handle(result_type()));
 
   // Set closure function's formal parameters to this formal parameters,
   // removing the receiver if this is an instance method.
   const int has_receiver = is_static() ? 0 : 1;
   const int num_fixed_params = num_fixed_parameters() - has_receiver;
-  const int num_opt_pos_params = num_optional_positional_parameters();
-  const int num_opt_named_params = num_optional_named_parameters();
-  const int num_params =
-      num_fixed_params + num_opt_pos_params + num_opt_named_params;
+  const int num_opt_params = NumOptionalParameters();
+  const bool has_opt_pos_params = HasOptionalPositionalParameters();
+  const int num_params = num_fixed_params + num_opt_params;
   closure_function.set_num_fixed_parameters(num_fixed_params);
-  closure_function.set_num_optional_positional_parameters(num_opt_pos_params);
-  closure_function.set_num_optional_named_parameters(num_opt_named_params);
+  closure_function.SetNumOptionalParameters(num_opt_params, has_opt_pos_params);
   closure_function.set_parameter_types(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   closure_function.set_parameter_names(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   AbstractType& param_type = AbstractType::Handle();
   String& param_name = String::Handle();
   for (int i = 0; i < num_params; i++) {
     param_type = ParameterTypeAt(i + has_receiver);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(i + has_receiver);
@@ skipping 72 matching lines @@
           pieces.Add(name);
         }
         if (i < num_type_parameters - 1) {
           pieces.Add(kCommaSpace);
         }
       }
       pieces.Add(kRAngleBracket);
     }
   }
   AbstractType& param_type = AbstractType::Handle();
-  const intptr_t num_params = NumberOfParameters();
+  const intptr_t num_params = NumParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
-  const intptr_t num_opt_pos_params = num_optional_positional_parameters();
-  const intptr_t num_opt_named_params = num_optional_named_parameters();
+  const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
+  const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   pieces.Add(kLParen);
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
     if (instantiate && !param_type.IsInstantiated()) {
       param_type = param_type.InstantiateFrom(instantiator);
     }
     name = param_type.BuildName(name_visibility);
@@ skipping 44 matching lines @@
   const Array& strings = Array::Handle(Array::MakeArray(pieces));
   return Symbols::New(String::Handle(String::ConcatAll(strings)));
 }
 
 
 bool Function::HasInstantiatedSignature() const {
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated()) {
     return false;
   }
-  const intptr_t num_parameters = NumberOfParameters();
+  const intptr_t num_parameters = NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = ParameterTypeAt(i);
     if (!type.IsInstantiated()) {
       return false;
     }
   }
   return true;
 }
 
 
@@ skipping 6752 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart