Generate a bit less code to handle failed arity checks.

Source/bindings/scripts/code_generator_v8.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 2236 matching lines @@
     # values passed in non-primitive argument slots. When more than a single
     # overload is applicable, precedence is given according to the order of
     # declaration in the IDL.
 
     my $name = $function->name;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
     my $conditionalString = GenerateConditionalString($function);
     my $leastNumMandatoryParams = 255;
-    my $code = "";
-    $code .= "#if ${conditionalString}\n\n" if $conditionalString;
-    $code .= <<END;
+
+    my $hasExceptionState = 0;
+    my $header = "";
+    $header .= "#if ${conditionalString}\n\n" if $conditionalString;
+    $header .= <<END;
 static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
+    my $code = "";
     $code .= GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
 
     foreach my $overload (@{$function->{overloads}}) {
         my ($numMandatoryParams, $parametersCheck) = GenerateFunctionParametersCheck($overload);
         $leastNumMandatoryParams = $numMandatoryParams if ($numMandatoryParams < $leastNumMandatoryParams);
         $code .= "    if ($parametersCheck) {\n";
         my $overloadedIndexString = $overload->{overloadIndex};
         $code .= "        ${name}${overloadedIndexString}Method${forMainWorldSuffix}(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
+        if (!$hasExceptionState) {
+            AddToImplIncludes("bindings/v8/ExceptionMessages.h");
+            AddToImplIncludes("bindings/v8/ExceptionState.h");
+            $header .= "    ExceptionState exceptionState(ExceptionState::ExecutionContext, \"${name}\", \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
+            $hasExceptionState = 1;
+        }
         $code .= "    if (UNLIKELY(info.Length() < $leastNumMandatoryParams)) {\n";
-        $code .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$name\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, info.Length())), info.GetIsolate());\n";
+        $code .= "        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, info.Length()));\n";
+        $code .= "        exceptionState.throwIfNeeded();\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
-    $code .= <<END;
-    throwTypeError(ExceptionMessages::failedToExecute(\"$name\", \"$interfaceName\", \"No function was found that matched the signature provided.\"), info.GetIsolate());
+    if ($hasExceptionState) {
+        $code .= <<END;
+    exceptionState.throwTypeError(\"No function was found that matched the signature provided.\");
+    exceptionState.throwIfNeeded();
 END
+    } else {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
+        $code .=<<END;
+    throwTypeError(ExceptionMessages::failedToExecute(\"${name}\", \"${interfaceName}\", \"No function was found that matched the signature provided.\"), info.GetIsolate());
+END
+    }
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
-    $implementation{nameSpaceInternal}->add($code);
+    $implementation{nameSpaceInternal}->add($header . $code);
 }
 
 sub GenerateFunctionCallback
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
@@ skipping 58 matching lines @@
     $code .= "{\n";
 
     # We throw exceptions using 'ExceptionState' if the function explicitly claims that exceptions
     # may be raised, or for event listeners, or for security-checking, and for weird SVG stuff.
     my $isEventListener = $name eq "addEventListener" || $name eq "removeEventListener";
     my $isSecurityCheckNecessary = $interface->extendedAttributes->{"CheckSecurity"} && !$function->extendedAttributes->{"DoNotCheckSecurity"};
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
     my $isNonListSVGType = $svgNativeType && !($interfaceName =~ /List$/);
 
+    my $hasExceptionState = 0;
     if ($raisesExceptions || $isEventListener || $isSecurityCheckNecessary || $isNonListSVGType) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState exceptionState(ExceptionState::ExecutionContext, \"${unoverloadedName}\", \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
+        $hasExceptionState = 1;
     }
 
     if ($isEventListener) {
         my $lookupType = ($name eq "addEventListener") ? "OrCreate" : "Only";
         my $passRefPtrHandling = ($name eq "addEventListener") ? "" : ".get()";
         my $hiddenDependencyAction = ($name eq "addEventListener") ? "create" : "remove";
 
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         AddToImplIncludes("bindings/v8/V8EventListenerList.h");
         AddToImplIncludes("core/frame/DOMWindow.h");
@@ skipping 15 matching lines @@
             ${hiddenDependencyAction}HiddenDependency(info.Holder(), info[1], ${v8ClassName}::eventListenerCacheIndex, info.GetIsolate());
     }
 }
 END
         $code .= "#endif // ${conditionalString}\n" if $conditionalString;
         $code .= "\n";
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
-    $code .= GenerateArgumentsCountCheck($function, $interface);
+    $code .= GenerateArgumentsCountCheck($function, $interface, $hasExceptionState);
 
     if ($svgNativeType) {
         my $nativeClassName = GetNativeType($interfaceName);
         if ($interfaceName =~ /List$/) {
             $code .= "    $nativeClassName imp = ${v8ClassName}::toNative(info.Holder());\n";
         } else {
             AddToImplIncludes("core/dom/ExceptionCode.h");
             $code .= "    $nativeClassName wrapper = ${v8ClassName}::toNative(info.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
             $code .= "        exceptionState.throwDOMException(NoModificationAllowedError, \"The object is read-only.\");\n";
@@ skipping 79 matching lines @@
     if (ExtendedAttributeContains($callWith, "FirstWindow")) {
         push(@callWithArgs, "firstDOMWindow()");
     }
     return ([@callWithArgs], $code);
 }
 
 sub GenerateArgumentsCountCheck
 {
     my $function = shift;
     my $interface = shift;
+    my $hasExceptionState = shift;
 
     my $functionName = $function->name;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
     my $numMandatoryParams = 0;
     my $allowNonOptional = 1;
     foreach my $param (@{$function->parameters}) {
         if ($param->isOptional or $param->isVariadic) {
             $allowNonOptional = 0;
         } else {
             die "An argument must not be declared to be optional unless all subsequent arguments to the operation are also optional." if !$allowNonOptional;
             $numMandatoryParams++;
         }
     }
 
     my $argumentsCountCheckString = "";
     if ($numMandatoryParams >= 1) {
         $argumentsCountCheckString .= "    if (UNLIKELY(info.Length() < $numMandatoryParams)) {\n";
-        $argumentsCountCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($numMandatoryParams, info.Length())), info.GetIsolate());\n";
+        if ($hasExceptionState) {
+            $argumentsCountCheckString .= "        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments($numMandatoryParams, info.Length()));\n";
+            $argumentsCountCheckString .= "        exceptionState.throwIfNeeded();\n";
+        } else {
+            $argumentsCountCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$interfaceName\", ExceptionMessages::notEnoughArguments($numMandatoryParams, info.Length())), info.GetIsolate());\n";
+        }
         $argumentsCountCheckString .= "        return;\n";
         $argumentsCountCheckString .= "    }\n";
     }
     return $argumentsCountCheckString;
 }
 
 sub GenerateParametersCheck
 {
     my $function = shift;
     my $interface = shift;
@@ skipping 148 matching lines @@
     }
     return ($parameterCheckString, $paramIndex, %replacements);
 }
 
 sub GenerateOverloadedConstructorCallback
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
-    my $code = "";
-    $code .= <<END;
+    my $hasExceptionState = 0;
+    my $header = "";
+    $header .= <<END;
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
+    my $code = "";
     my $leastNumMandatoryParams = 255;
     foreach my $constructor (@{$interface->constructors}) {
         my $name = "constructor" . $constructor->overloadedIndex;
         my ($numMandatoryParams, $parametersCheck) = GenerateFunctionParametersCheck($constructor);
         $leastNumMandatoryParams = $numMandatoryParams if ($numMandatoryParams < $leastNumMandatoryParams);
         $code .= "    if ($parametersCheck) {\n";
         $code .= "        ${implClassName}V8Internal::${name}(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
+        if (!$hasExceptionState) {
+            AddToImplIncludes("bindings/v8/ExceptionMessages.h");
+            AddToImplIncludes("bindings/v8/ExceptionState.h");
+            $header .= "    ExceptionState exceptionState(ExceptionState::ConstructionContext, \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
+            $hasExceptionState = 1;
+        }
         $code .= "    if (UNLIKELY(info.Length() < $leastNumMandatoryParams)) {\n";
-
-        $code .= "        throwTypeError(ExceptionMessages::failedToConstruct(\"$interfaceName\", ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, info.Length())), info.GetIsolate());\n";
+        $code .= "        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments($leastNumMandatoryParams, info.Length()));\n";
+        $code .= "        exceptionState.throwIfNeeded();\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
-    $code .= <<END;
-    throwTypeError(ExceptionMessages::failedToConstruct(\"$interfaceName\", \"No matching constructor signature.\"), info.GetIsolate());
-    return;
+    if ($hasExceptionState) {
+        $code .= <<END;
+    exceptionState.throwTypeError(\"No matching constructor signature.\");
+    exceptionState.throwIfNeeded();
 END
+    } else {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
+        $code .= <<END;
+    throwTypeError(ExceptionMessages::failedToConstruct(\"${interfaceName}\", \"No matching constructor signature.\"), info.GetIsolate());
+END
+    }
     $code .= "}\n\n";
-    $implementation{nameSpaceInternal}->add($code);
+    $implementation{nameSpaceInternal}->add($header . $code);
 }
 
 sub GenerateSingleConstructorCallback
 {
     my $interface = shift;
     my $function = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $overloadedIndexString = "";
     if ($function->overloadedIndex > 0) {
         $overloadedIndexString .= $function->overloadedIndex;
     }
 
     my $constructorRaisesException = $interface->extendedAttributes->{"RaisesException"} && $interface->extendedAttributes->{"RaisesException"} eq "Constructor";
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"} || $constructorRaisesException;
 
     my @beforeArgumentList;
     my @afterArgumentList;
     my $code = "";
     $code .= <<END;
 static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
 
     if ($function->overloadedIndex == 0) {
-        $code .= GenerateArgumentsCountCheck($function, $interface);
+        my $hasExceptionState = 0;
+        $code .= GenerateArgumentsCountCheck($function, $interface, $hasExceptionState);
     }
 
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
     }
 
     # FIXME: Currently [Constructor(...)] does not yet support optional arguments without [Default=...]
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "");
     $code .= $parameterCheckString;
@@ skipping 319 matching lines @@
     $code .= <<END;
     Document* document = currentDocument();
     ASSERT(document);
 
     // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} instance
     // may end up being the only node in the map and get garbage-collected prematurely.
     toV8(document, info.Holder(), info.GetIsolate());
 
 END
 
-    $code .= GenerateArgumentsCountCheck($function, $interface);
-
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
-        $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
+        my $interfaceName = $interface->name;
+        $code .= "    ExceptionState exceptionState(ExceptionState::ConstructionContext, \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
     }
 
+    my $hasExceptionState = $raisesExceptions;
+    $code .= GenerateArgumentsCountCheck($function, $interface, $hasExceptionState);
+
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "*document");
 
     if ($constructorRaisesException) {
         push(@afterArgumentList, "exceptionState");
     }
 
     my @argumentList;
@@ skipping 3245 matching lines @@
 
     return 1 if ExtendedAttributeContains($interface->extendedAttributes->{"Custom"}, "ToV8");
     return 1 if ExtendedAttributeContains($interface->extendedAttributes->{"Custom"}, "Wrap");
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
 
     return 0;
 }
 
 1;