IDL: Determine maximum distinguishing argument index runtime, if needed

Source/bindings/templates/methods.cpp

 {% from 'conversions.cpp' import declare_enum_validation_variable, v8_value_to_local_cpp_value %}
 
 
 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 {% filter conditional(method.conditional_string) %}
 {% if method.returns_promise and method.has_exception_state %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}Promise(const v8::FunctionCallbackInfo<v8::Value>& info, ExceptionState& exceptionState)
 {% else %}
 static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 334 matching lines @@
     {% filter runtime_enabled(runtime_enabled_function) %}
     return {{length}};
     {% endfilter %}
     {% endfor %}
     {% endfor %}
 }
 {% endmacro %}
 
 
 {##############################################################################}
+{% macro runtime_determined_maxarg_method(overloads) %}
+static int {{overloads.name}}MethodMaxArg()
+{
+    {% for length, runtime_enabled_functions in overloads.runtime_determined_maxargs %}
+    {% for runtime_enabled_function in runtime_enabled_functions %}
+    {% filter runtime_enabled(runtime_enabled_function) %}
+    return {{length}};
+    {% endfilter %}
+    {% endfor %}
+    {% endfor %}
+}
+{% endmacro %}
+
+
+{##############################################################################}
 {# FIXME: We should return a rejected Promise if an error occurs in this
 function when ALL methods in this overload return Promise. In order to do so,
 we must ensure either ALL or NO methods in this overload return Promise #}
 {% macro overload_resolution_method(overloads, world_suffix) %}
 static void {{overloads.name}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{overloads.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% if overloads.measure_all_as %}
     UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::{{overloads.measure_all_as}});
     {% endif %}
@@ skipping 29 matching lines @@
     {% endfor %}
     {% if is_partial or not overloads.has_partial_overloads %}
     default:
         {# If methods are overloaded between interface and partial interface #}
         {# definitions, need to invoke methods defined in the partial #}
         {# interface. #}
         {# FIXME: we do not need to always generate this code. #}
         {# Invalid arity, throw error #}
         {# Report full list of valid arities if gaps and above minimum #}
         {% if overloads.valid_arities %}
-        if (info.Length() >= {{overloads.minarg}}) {
+        if (info.Length() >= {{overloads.length}}) {
             setArityTypeError(exceptionState, "{{overloads.valid_arities}}", info.Length());
             {{propagate_error_with_exception_state(overloads) | indent(12)}}
         }
         {% endif %}
         break;
     {% endif %}
     }
     {% if not is_partial and overloads.has_partial_overloads %}
     ASSERT({{overloads.name}}MethodForPartialInterface);
     ({{overloads.name}}MethodForPartialInterface)(info);
@@ skipping 226 matching lines @@
                   method.exposed_test) %}
 {% filter runtime_enabled(method.overloads.runtime_enabled_function_all
                           if method.overloads else
                           method.runtime_enabled_function) %}
 prototypeObject->Set(v8AtomicString(isolate, "{{method.name}}"), v8::FunctionTemplate::New(isolate, {{cpp_class_or_partial}}V8Internal::{{method.name}}MethodCallback, v8Undefined(), defaultSignature, {{method.number_of_required_arguments}})->GetFunction(isolate->GetCurrentContext()).ToLocalChecked());
 {% endfilter %}{# runtime_enabled() #}
 {% endfilter %}{# exposed() #}
 {% endfor %}
 {% endif %}
 {%- endmacro %}