IDL compiler: [Constructor] overloading

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
 {% set getter_callback =
        '%sV8Internal::%sAttributeGetterCallback' %
             (cpp_class, attribute.name)
        if not attribute.constructor_type else
        '{0}V8Internal::{0}ConstructorGetter'.format(interface_name) %}
@@ skipping 111 matching lines @@
     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
     {{cpp_class}}V8Internal::{{cpp_class}}OriginSafeMethodSetter(name, jsValue, info);
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
-{% from 'methods.cpp' import generate_argument with context %}
-{% block constructor %}
-{% if has_constructor %}
-{# FIXME: support overloading #}
+{% block overloaded_constructor_callback %}

[Nils Barth (inactive), 2013/12/13 07:04:16]

Diff looks weird; just look at new code.

This is b/c |constructor| block moved to macro in methods.cpp,
since needs to take a parameter (the constructor) and need to avoid
circular import,
and then new overload callback block added.

+{% if constructors|length > 1 %}
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    {% if constructor_arguments %}
-    {# FIXME: remove this UNLIKELY: constructors are heavy, so no difference. #}
-    if (UNLIKELY(info.Length() < {{interface_length}})) {
-        throwTypeError(ExceptionMessages::failedToExecute("Constructor", "{{interface_name}}", ExceptionMessages::notEnoughArguments({{interface_length}}, info.Length())), info.GetIsolate());
+    {% for constructor in constructors %}
+    if ({{constructor.overload_resolution_expression}}) {
+        {{cpp_class}}V8Internal::constructor{{constructor.overload_index}}(info);
         return;
     }
+    {% endfor %}
+    {% if interface_length %}
+    ExceptionState exceptionState(ExceptionState::ConstructionContext, "{{interface_name}}", info.Holder(), info.GetIsolate());
+    if (UNLIKELY(info.Length() < {{interface_length}})) {
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments({{interface_length}}, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No matching constructor signature.");
+    exceptionState.throwIfNeeded();
+    {% else %}
+    throwTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", "No matching constructor signature."), info.GetIsolate());
     {% endif %}
-    {% if is_constructor_raises_exception %}
-    ExceptionState exceptionState(ExceptionState::ConstructionContext, "{{interface_name}}", info.Holder(), info.GetIsolate());
-    {% endif %}
-    {% for argument in constructor_arguments %}
-    {{generate_argument(constructor_method, argument) | indent}}
-    {% endfor %}
-    {% if is_constructor_call_with_execution_context %}
-    ExecutionContext* context = getExecutionContext();
-    {% endif %}
-    {% if is_constructor_call_with_document %}
-    Document& document = *toDocument(getExecutionContext());
-    {% endif %}
-    RefPtr<{{cpp_class}}> impl = {{cpp_class}}::create({{constructor_argument_list | join(', ')}});
-    v8::Handle<v8::Object> wrapper = info.Holder();
-    {% if is_constructor_raises_exception %}
-    if (exceptionState.throwIfNeeded())
-        return;
-    {% endif %}
-
-    V8DOMWrapper::associateObjectWithWrapper<{{v8_class}}>(impl.release(), &{{v8_class}}::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
-    v8SetReturnValue(info, wrapper);
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block event_constructor %}
 {% if has_event_constructor %}
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 154 matching lines @@
     {% endfor %}
     return true;
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
 {% block constructor_callback %}
-{% if has_constructor or has_event_constructor %}
+{% if constructors or has_event_constructor %}
 void {{v8_class}}::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "DOMConstructor");
     {% if measure_as %}
     UseCounter::count(activeDOMWindow(), UseCounter::{{measure_as}});
     {% endif %}
     if (!info.IsConstructCall()) {
         throwTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", "Please use the 'new' operator, this DOM object constructor cannot be called as a function."), info.GetIsolate());
         return;
     }
@@ skipping 41 matching lines @@
         {% set methods_name, methods_length =
                ('%sMethods' % v8_class,
                 'WTF_ARRAY_LENGTH(%sMethods)' % v8_class)
            if has_method_configuration else (0, 0) %}
         {{attributes_name}}, {{attributes_length}},
         {{accessors_name}}, {{accessors_length}},
         {{methods_name}}, {{methods_length}},
         isolate, currentWorldType);
     {% endfilter %}
 
-    {% if has_constructor or has_event_constructor %}
+    {% if constructors or has_event_constructor %}
     functionTemplate->SetCallHandler({{v8_class}}::constructorCallback);
     functionTemplate->SetLength({{interface_length}});
     {% endif %}
     v8::Local<v8::ObjectTemplate> ALLOW_UNUSED instanceTemplate = functionTemplate->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> ALLOW_UNUSED prototypeTemplate = functionTemplate->PrototypeTemplate();
     {% if is_check_security and interface_name != 'Window' %}
     instanceTemplate->SetAccessCheckCallbacks({{cpp_class}}V8Internal::namedSecurityCheck, {{cpp_class}}V8Internal::indexedSecurityCheck, v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&{{v8_class}}::wrapperTypeInfo)));
     {% endif %}
     {% for attribute in attributes if attribute.runtime_enabled_function %}
     {% filter conditional(attribute.conditional_string) %}
@@ skipping 274 matching lines @@
     fromInternalPointer(object)->deref();
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}