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

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 103 matching lines @@
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
 
 LocalVariable* ParsedFunction::GetSavedArgumentsDescriptorVar() const {
-  const int num_parameters = function().NumberOfParameters();
+  const int num_parameters = function().NumParameters();
   LocalScope* scope = node_sequence()->scope();
   if (scope->num_variables() > num_parameters) {
     LocalVariable* saved_args_desc_var = scope->VariableAt(num_parameters);
     ASSERT(saved_args_desc_var != NULL);
     // The scope of the formal parameters may also contain at this position
     // an alias for the saved arguments descriptor variable of the enclosing
     // function (check its scope owner) or an internal variable such as the
     // expression temp variable or the saved entry context variable (check its
     // name).
     if ((saved_args_desc_var->owner() == scope) &&
         saved_args_desc_var->name().StartsWith(
             String::Handle(Symbols::SavedArgDescVarPrefix()))) {
       return saved_args_desc_var;
     }
   }
   return NULL;
 }
 
 
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   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;
+  const intptr_t num_opt_params = function().NumOptionalParameters();
   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 ((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 + num_params;
@@ skipping 1767 matching lines @@
       &String::ZoneHandle(Symbols::PhaseParameter()),
       &Type::ZoneHandle(Type::SmiType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
-  ASSERT(func.NumberOfParameters() == params.parameters->length());
+  ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Initialize instance fields that have an explicit initializer expression.
   // The formal parameter names must not be visible to the instance
   // field initializer expressions, yet the parameters must be added to
   // the scope so the expressions use the correct offsets for 'this' when
   // storing values. We make the formal parameters temporarily invisible
   // while parsing the instance field initializer expressions.
@@ skipping 244 matching lines @@
     }
   }
 
   // The number of parameters and their type are not yet set in local functions,
   // since they are not 'top-level' parsed.
   if (func.IsLocalFunction()) {
     AddFormalParamsToFunction(&params, func);
   }
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
-  ASSERT(func.NumberOfParameters() == params.parameters->length());
+  ASSERT(func.NumParameters() == params.parameters->length());
 
   // Check whether the function has any field initializer formal parameters,
   // which are not allowed in non-constructor functions.
   if (params.has_field_initializer) {
     for (int i = 0; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         ErrorMsg(param.name_pos,
                  "field initializer only allowed in constructors");
       }
@@ skipping 2226 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));
   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);
+  if (!Utils::IsInt(16, params->num_fixed_parameters) ||
+      !Utils::IsInt(16, params->num_optional_parameters)) {
+    ErrorMsg("too many formal parameters");
+  }
+  func.set_num_fixed_parameters(params->num_fixed_parameters);
+  func.SetNumOptionalParameters(params->num_optional_parameters,
+                                params->has_optional_positional_parameters);
   const int num_parameters = params->parameters->length();
-  ASSERT(num_parameters == func.NumberOfParameters());
+  ASSERT(num_parameters == func.NumParameters());
   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);
     func.SetParameterNameAt(i, *param_desc.name);
   }
@@ skipping 3157 matching lines @@
     // enclosing functions, or a compile error would have prevented the
     // outermost enclosing function to be executed and we would not be compiling
     // this local function.
     // Therefore, look for ident directly in the formal parameter lists of the
     // enclosing functions.
     // There is no need to return the owner_scope, since the caller will not
     // create the saved_arguments_descriptor variable, which already exists.
     Function& function = Function::Handle(innermost_function().raw());
     String& param_name = String::Handle();
     do {
-      const int num_parameters = function.NumberOfParameters();
+      const int num_parameters = function.NumParameters();
       for (intptr_t i = 0; i < num_parameters; i++) {
         param_name = function.ParameterNameAt(i);
         if (ident.Equals(param_name)) {
           *owner_function = function.raw();
           *owner_scope = NULL;
           *local_index = i;
           return true;
         }
       }
       function = function.parent_function();
     } while (!function.IsNull());
     UNREACHABLE();
   }
   // Verify that local is a formal parameter of the current function or of one
   // of its enclosing functions.
   // Note that scopes are not yet associated to functions.
   Function& function = Function::Handle(innermost_function().raw());
   LocalScope* scope = current_block_->scope;
   while (scope != NULL) {
     ASSERT(!function.IsNull());
     // Find the top scope for this function level.
     while ((scope->parent() != NULL) &&
            (scope->parent()->function_level() == scope->function_level())) {
       scope = scope->parent();
     }
     if (scope == local->owner()) {
       // Scope contains 'local' and the formal parameters of 'function'.
-      const int num_parameters = function.NumberOfParameters();
+      const int num_parameters = function.NumParameters();
       for (intptr_t i = 0; i < num_parameters; i++) {
         if (scope->VariableAt(i) == local) {
           *owner_function = function.raw();
           *owner_scope = scope;
           *local_index = i;
           return true;
         }
       }
       // The variable 'local' is not a formal parameter.
       return false;
@@ skipping 1436 matching lines @@
     ASSERT(owner_scope != NULL);
     saved_args_desc_var =
         new LocalVariable(owner_function.token_pos(),
                           saved_args_desc_name,
                           Type::ZoneHandle(Type::ListInterface()));
     saved_args_desc_var->set_is_final();
     // The saved arguments descriptor variable must be added just after the
     // formal parameters. This simplifies the 2-step saving of a captured
     // arguments descriptor.
     // At this time, the owner scope should only contain formal parameters.
-    ASSERT(owner_scope->num_variables() == owner_function.NumberOfParameters());
+    ASSERT(owner_scope->num_variables() == owner_function.NumParameters());
     bool success = owner_scope->AddVariable(saved_args_desc_var);
     ASSERT(success);
     // Capture the saved argument descriptor variable if necessary.
     LocalVariable* local = LookupLocalScope(saved_args_desc_name);
     ASSERT(local == saved_args_desc_var);
   }
   // If we currently generate code for the local function of an enclosing owner
   // function, the saved arguments descriptor variable must have been captured
   // by the above lookup.
   ASSERT((owner_function.raw() == innermost_function().raw()) ||
@@ skipping 428 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart