Make length property return useful values for DOM bindings functions

Source/bindings/scripts/CodeGeneratorV8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 2121 matching lines @@
 
     if ($raisesExceptions) {
         push(@implContentInternals, "    fail:\n");
         push(@implContentInternals, "    return setDOMException(ec, args.GetIsolate());\n");
     }
 
     push(@implContentInternals, "}\n");
     push(@implContentInternals, "\n");
 }
 
+sub GetConstructorLength
+{
+    my $interface = shift;
+
+    my $numberOfConstructorParameters = $interface->extendedAttributes->{"ConstructorParameters"};
+    if (!defined $numberOfConstructorParameters) {
+        if ($codeGenerator->IsConstructorTemplate($interface, "Event")) {
+            $numberOfConstructorParameters = 2;
+        } elsif ($codeGenerator->IsConstructorTemplate($interface, "TypedArray")) {
+            $numberOfConstructorParameters = 1;
+        } elsif ($interface->extendedAttributes->{"Constructor"}) {
+            my @constructors = @{$interface->constructors};
+            $numberOfConstructorParameters = 255;
+            foreach my $constructor (@constructors) {
+                my $currNumberOfParameters = @{$constructor->parameters};
+                if ($currNumberOfParameters < $numberOfConstructorParameters) {
+                    $numberOfConstructorParameters = $currNumberOfParameters;

[haraken, 2013/04/16 00:29:31]

I'm not sure if this is correct. Per the spec, it looks like you have to report
# of mandatory arguments (i.e. not including optional parameters).
http://www.w3.org/TR/WebIDL/#es-interface-call

[do-not-use, 2013/04/16 07:26:23]

Sorry, could you point me to the part where it says we should only count
mandatory arguments? I cannot find it. What I could find at the link you
provided is:

"""
 Interface objects for interfaces declared with a [Constructor] extended
attribute MUST have a property named “length” with attributes { [[Writable]]:
false, [[Enumerable]]: false, [[Configurable]]: false } whose value is a Number
determined as follows:

    Let id be the identifier of interface I.
    Initialize S to the effective overload set for constructors with identifier
id on interface I and with argument count 0.
    Return the maximum argument list length of the constructors in the entries
of S.
"""

If I understand correctly, we need to select the maximum argument list length
among all the constructors, counting optional arguments. My patch is actually
currently doing the opposite (selecting the minimum argument list length).

[do-not-use, 2013/04/16 09:39:20]

Actually, the latest Editor Draft matches the behavior you were mentioning:
http://dev.w3.org/2006/webapi/WebIDL/#es-interface-call

This was changed about 6 month ago. So I guess we should follow the latest
editor draft and use the shortest argument list in the effective overload set
instead? This also means that optional arguments are not counted due to the
definition of an "effective overload set"
(http://dev.w3.org/2006/webapi/WebIDL/#dfn-effective-overload-set).

+                }
+            }
+        }
+    }
+
+    return $numberOfConstructorParameters;
+}
+
 sub GenerateConstructorCallback
 {
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     push(@implContent, "v8::Handle<v8::Value> V8${interfaceName}::constructorCallback(const v8::Arguments& args)\n");
     push(@implContent, "{\n");
     push(@implContent, GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"}));
     push(@implContent, GenerateConstructorHeader());
     if (HasCustomConstructor($interface)) {
@@ skipping 889 matching lines @@
         next if !IsStandardFunction($interface, $function);
         if (!$has_callbacks) {
             $has_callbacks = 1;
             push(@implContent, "static const V8DOMConfiguration::BatchedMethod ${v8InterfaceName}Methods[] = {\n");
         }
         my $name = $function->signature->name;
         my $methodForMainWorld = "0";
         if ($function->signature->extendedAttributes->{"PerWorldBindings"}) {
             $methodForMainWorld = "${interfaceName}V8Internal::${name}MethodCallbackForMainWorld";
         }
+        my $numParams = @{$function->parameters};
         my $conditionalString = $codeGenerator->GenerateConditionalString($function->signature);
         push(@implContent, "#if ${conditionalString}\n") if $conditionalString;
         push(@implContent, <<END);
-    {"$name", ${interfaceName}V8Internal::${name}MethodCallback, ${methodForMainWorld}},
+    {"$name", ${interfaceName}V8Internal::${name}MethodCallback, ${methodForMainWorld}, ${numParams}},
 END
         push(@implContent, "#endif\n") if $conditionalString;
         $num_callbacks++;
     }
     push(@implContent, "};\n\n")  if $has_callbacks;
 
     # Setup constants
     my $has_constants = 0;
     my @constantsEnabledAtRuntime;
     if (@{$interface->constants}) {
@@ skipping 114 matching lines @@
 END
     }
 
     AddToImplIncludes("wtf/UnusedParam.h");
     push(@implContent, <<END);
     UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
 END
 
     if (IsConstructable($interface)) {
         push(@implContent, "    desc->SetCallHandler(${v8InterfaceName}::constructorCallback);\n");
+        my $constructorLength = GetConstructorLength($interface);
+        push(@implContent, "    desc->SetLength(${constructorLength});\n") if defined $constructorLength;

[haraken, 2013/04/16 00:29:31]

'if defined' is not needed.

     }
 
     if ($access_check or @enabledAtRuntimeAttributes or @normalFunctions or $has_constants) {
         push(@implContent,  <<END);
     v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
     UNUSED_PARAM(instance); // In some cases, it will not be used.
     UNUSED_PARAM(proto); // In some cases, it will not be used.
 END
     }
@@ skipping 1389 matching lines @@
 
 sub GetPassRefPtrType
 {
     my $v8InterfaceName = shift;
 
     my $angleBracketSpace = $v8InterfaceName =~ />$/ ? " " : "";
     return "PassRefPtr<${v8InterfaceName}${angleBracketSpace}>";
 }
 
 1;