Skip expensive hasInstance() type-checks in overloads

Source/bindings/templates/methods.cpp

 {##############################################################################}
 {% macro generate_method(method, world_suffix) %}
 {% filter conditional(method.conditional_string) %}
-static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const v8::FunctionCallbackInfo<v8::Value>& info{% if method.overload_index %}, int type_checked_argument_index{% endif %})
 {
     {# Local variables #}
     {% if method.has_exception_state %}
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "{{method.name}}", "{{interface_name}}", info.Holder(), info.GetIsolate());
     {% endif %}
     {# Overloaded methods have length checked during overload resolution #}
     {% if method.number_of_required_arguments and not method.overload_index %}
     if (UNLIKELY(info.Length() < {{method.number_of_required_arguments}})) {
         {{throw_minimum_arity_type_error(method, method.number_of_required_arguments) | indent(8)}}
         return;
@@ skipping 150 matching lines @@
 {% elif argument.is_dictionary %}
 {# Dictionaries must have type Undefined, Null or Object:
 http://heycam.github.io/webidl/#es-dictionary #}
 if (!isUndefinedOrNull(info[{{argument.index}}]) && !info[{{argument.index}}]->IsObject()) {
     {{throw_type_error(method, '"parameter %s (\'%s\') is not an object."' %
                                (argument.index + 1, argument.name)) | indent}}
     return;
 }
 {{argument.v8_value_to_local_cpp_value}};
 {% else %}{# argument.is_nullable #}
+{# Optionally do an "unsafe" type conversion if meaningful for this argument's
+   type and if this method is overloaded and the argument's type was checked as
+   part of overload resolution for this particular call. #}
+{% if method.overload_index and
+   argument.is_distinguishing_argument and
+   argument.v8_value_to_local_cpp_value_unsafe %}
+if (type_checked_argument_index == {{argument.index}})

[haraken, 2014/10/14 13:54:07]

Help me understand: I'm curious about the relationship between
argument.is_distinguishing_argument and 'type_checked_argument_index ==
{{argument.index}}'. Is it possible that the argument is an distinguishing
argument but 'type_checked_argument_index == {{argument.index}}' does not hold?

I was expecting that type is always checked if the argument is an distinguishing
argument.

[Jens Widell, 2014/10/14 14:37:56]

Yes, it's possible. The key complexity here (which makes the other approach
intricate) is that different arguments (to the same method) can theoretically be
the distinguishing argument, depending on the number of arguments in the call.

I could have called 'is_distinguishing_argument' something better, I think.
Maybe 'is_ever_distinguishing_argument'. It's really just an optimization;
skipping the runtime check for arguments that are never the distinguishing
argument (which we can trivially know compile-time.)
An easy mistake to make. :-)

Consider HTMLSelectElement.add(), which has these overloads:

  void add(HTMLElement element, optional HTMLElement? before = null);
  void add(HTMLElement element, long before);

The first one could be called with the argument lists

  (anElement)
  (anElement, null)
  (anElement, anotherElement)

In the last case, 'before' is type-checked and add1Method() is called with
type_checked_argument_index=1. In the first two cases, no relevant type-checking
will have been made before add1Method() is called, and add1Method() is called
with type_checked_argument_index=-1, which means it uses toImplWithTypeCheck()
(unless info.Length()<2, which uses the default value code path, of course.)

And add2Method() is always called with no prior (relevant) type-checking.

+    {{argument.v8_value_to_local_cpp_value_unsafe}};
+else
+    {{argument.v8_value_to_local_cpp_value}};
+{% else %}
 {{argument.v8_value_to_local_cpp_value}};
+{% endif %}
 {% endif %}{# argument.is_nullable #}
 {# Type checking, possibly throw a TypeError, per:
    http://www.w3.org/TR/WebIDL/#es-type-mapping #}
 {% if argument.has_type_checking_unrestricted %}
 {# Non-finite floating point values (NaN, +Infinity or −Infinity), per:
    http://heycam.github.io/webidl/#es-float
    http://heycam.github.io/webidl/#es-double #}
 if (!std::isfinite({{argument.name}})) {
     {{throw_type_error(method, '"%s parameter %s is non-finite."' %
                                (argument.idl_type, argument.index + 1)) | indent}}
@@ skipping 184 matching lines @@
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::{{overloads.deprecate_all_as}});
     {% endif %}
     {# First resolve by length #}
     {# 2. Initialize argcount to be min(maxarg, n). #}
     switch (std::min({{overloads.maxarg}}, info.Length())) {
     {# 3. Remove from S all entries whose type list is not of length argcount. #}
     {% for length, tests_methods in overloads.length_tests_methods %}
     {# 10. If i = d, then: #}
     case {{length}}:
         {# Then resolve by testing argument #}
-        {% for test, method in tests_methods %}
+        {% for test, method, typed_checked_argument_index in tests_methods %}
         {% filter runtime_enabled(not overloads.runtime_enabled_function_all and
                                   method.runtime_enabled_function) %}
         if ({{test}}) {
             {% if method.measure_as and not overloads.measure_all_as %}
             UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::{{method.measure_as}});
             {% endif %}
             {% if method.deprecate_as and not overloads.deprecate_all_as %}
             UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::{{method.deprecate_as}});
             {% endif %}
-            {{method.name}}{{method.overload_index}}Method{{world_suffix}}(info);
+            {{method.name}}{{method.overload_index}}Method{{world_suffix}}(info, {{typed_checked_argument_index}});
             return;
         }
         {% endfilter %}
         {% endfor %}
         break;
     {% endfor %}
     default:
         {# Invalid arity, throw error #}
         {# Report full list of valid arities if gaps and above minimum #}
         {% if overloads.valid_arities %}
@@ skipping 139 matching lines @@
     return true;
 }
 {% endmacro %}
 
 
 {##############################################################################}
 {% macro generate_constructor(constructor) %}
 {% set name = '%sConstructorCallback' % v8_class
               if constructor.is_named_constructor else
               'constructor%s' % (constructor.overload_index or '') %}
-static void {{name}}(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void {{name}}(const v8::FunctionCallbackInfo<v8::Value>& info{% if constructor.overload_index %}, int type_checked_argument_index{% endif %})

[haraken, 2014/10/14 13:54:07]

type_checked_argument_index => typeCheckedArgumentIndex

Style checker is (intentionally) not enabled for auto-generated code.

 {
     {% if constructor.is_named_constructor %}
     if (!info.IsConstructCall()) {
         V8ThrowException::throwTypeError(ExceptionMessages::constructorNotCallableAsFunction("{{constructor.name}}"), info.GetIsolate());
         return;
     }
 
     if (ConstructorMode::current(info.GetIsolate()) == ConstructorMode::WrapExistingObject) {
         v8SetReturnValue(info, info.Holder());
         return;
@@ skipping 55 matching lines @@
   if method.is_per_world_bindings else '0' %}
 {% set property_attribute =
   'static_cast<v8::PropertyAttribute>(%s)' % ' | '.join(method.property_attributes)
   if method.property_attributes else 'v8::None' %}
 {% set only_exposed_to_private_script = 'V8DOMConfiguration::OnlyExposedToPrivateScript' if method.only_exposed_to_private_script else 'V8DOMConfiguration::ExposedToAllScripts' %}
 static const V8DOMConfiguration::MethodConfiguration {{method.name}}MethodConfiguration = {
     "{{method.name}}", {{method_callback}}, {{method_callback_for_main_world}}, {{method.length}}, {{only_exposed_to_private_script}},
 };
 V8DOMConfiguration::installMethod({{method.function_template}}, {{method.signature}}, {{property_attribute}}, {{method.name}}MethodConfiguration, isolate);
 {%- endmacro %}