Improve generated "Not enough arguments." TypeError exceptions.

Source/bindings/scripts/deprecated_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 1432 matching lines @@
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($attribute) . "())) {\n";
         $code .= "        v8SetReturnValueNull(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
 
     my $useExceptions = 1 if $attribute->extendedAttributes->{"GetterRaisesException"} ||  $attribute->extendedAttributes->{"RaisesException"};
     my $isNullable = $attribute->isNullable;
     if ($useExceptions) {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(info.GetIsolate());\n";
     }
 
     if ($isNullable) {
         $code .= "    bool isNull = false;\n";
     }
 
     my $returnType = $attribute->type;
     my $getterString;
@@ skipping 350 matching lines @@
     }
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
     if ($svgNativeType) {
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List$/) {
             $code .= <<END;
     $svgNativeType* imp = ${v8ClassName}::toNative(info.Holder());
 END
         } else {
+            AddToImplIncludes("bindings/v8/ExceptionMessages.h");
             AddToImplIncludes("bindings/v8/ExceptionState.h");
             $code .= "    $svgNativeType* wrapper = ${v8ClassName}::toNative(info.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
             $code .= "        setDOMException(NoModificationAllowedError, info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif ($attrExt->{"OnProto"}) {
@@ skipping 54 matching lines @@
     my $returnType = $attribute->type;
     if (IsRefPtrType($returnType) && !GetArrayType($returnType)) {
         $expression = "WTF::getPtr(" . $expression . ")";
     }
 
     $code .= GenerateCustomElementInvocationScopeIfNeeded($attribute->extendedAttributes);
 
     my $useExceptions = 1 if $attribute->extendedAttributes->{"SetterRaisesException"} ||  $attribute->extendedAttributes->{"RaisesException"};
 
     if ($useExceptions) {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(info.GetIsolate());\n";
     }
 
     if ($attribute->type eq "EventHandler") {
         my $implSetterFunctionName = FirstLetterToUpperCase($attrName);
         AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
         # Non callable input should be treated as null
         $code .= "    if (!value->IsNull() && !value->IsFunction())\n";
         $code .= "        value = v8::Null(info.GetIsolate());\n";
@@ skipping 152 matching lines @@
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     # Generate code for choosing the correct overload to call. Overloads are
     # chosen based on the total number of arguments passed and the type of
     # 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 $implClassName = GetImplName($interface);
 
     my $conditionalString = GenerateConditionalString($function);
     my $leastNumMandatoryParams = 255;
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 END
     $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}(args);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
         $code .= "    if (UNLIKELY(args.Length() < $leastNumMandatoryParams)) {\n";
-        $code .= "        throwNotEnoughArgumentsError(args.GetIsolate());\n";
+        $code .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$name\", \"$implClassName\", \"$leastNumMandatoryParams argument" . ($leastNumMandatoryParams > 1 ? "s" : "")  . " required, but only \" + String::number(args.Length()) + \" present.\"), args.GetIsolate());\n";

[marja, 2013/09/18 10:24:08]

Would it make sense to add a func to ExceptionMessages which produces a string
like:

"X argument(s) required but only Y present."

so that not all the places would need to construct the detail string themselves?

[Mike West, 2013/09/18 11:16:34]

I've added it, but I'm not sure it makes sense. Take a look and let me know what
you think.

[marja, 2013/09/18 11:23:50]

I like this version a lot better, merely the distribution of the "argument vs.
argumentS" logic in many places was hurting my brain. :)

         $code .= "        return;\n";
         $code .= "    }\n";
     }
     $code .= <<END;
     throwTypeError(args.GetIsolate());
 END
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
@@ skipping 110 matching lines @@
         return;
     }
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     if ($svgNativeType) {
         my $nativeClassName = GetNativeType($interfaceName);
         if ($interfaceName =~ /List$/) {
             $code .= "    $nativeClassName imp = ${v8ClassName}::toNative(args.Holder());\n";
         } else {
+            AddToImplIncludes("bindings/v8/ExceptionMessages.h");
             AddToImplIncludes("bindings/v8/ExceptionState.h");
             AddToImplIncludes("core/dom/ExceptionCode.h");
             $code .= "    $nativeClassName wrapper = ${v8ClassName}::toNative(args.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
             $code .= "        setDOMException(NoModificationAllowedError, args.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
             my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
@@ skipping 11 matching lines @@
         # We have not find real use cases yet.
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= <<END;
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame()))
         return;
 END
     }
 
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
     if ($raisesExceptions) {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(args.GetIsolate());\n";
     }
 
     if ($function->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($function) . "(es))) {\n";
         $code .= "        v8SetReturnValueNull(args);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
@@ skipping 44 matching lines @@
         push(@callWithArgs, "firstDOMWindow()");
     }
     return ([@callWithArgs], $code);
 }
 
 sub GenerateArgumentsCountCheck
 {
     my $function = shift;
     my $interface = shift;
 
+    my $functionName = $function->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(args.Length() < $numMandatoryParams)) {\n";
-        $argumentsCountCheckString .= "        throwNotEnoughArgumentsError(args.GetIsolate());\n";
+        $argumentsCountCheckString .= "        throwTypeError(ExceptionMessages::failedToExecute(\"$functionName\", \"$implClassName\", \"$numMandatoryParams argument" . ($numMandatoryParams > 1 ? "s" : "")  . " required, but only \" + String::number(args.Length()) + \" present.\"), args.GetIsolate());\n";
         $argumentsCountCheckString .= "        return;\n";
         $argumentsCountCheckString .= "    }\n";
     }
     return $argumentsCountCheckString;
 }
 
 sub GenerateParametersCheck
 {
     my $function = shift;
     my $interface = shift;
@@ skipping 13 matching lines @@
         if ($parameter->isOptional && !$parameter->extendedAttributes->{"Default"} && $nativeType ne "Dictionary" && !IsCallbackInterface($parameter->type)) {
             $parameterCheckString .= "    if (UNLIKELY(args.Length() <= $paramIndex))";
             my $functionCall = GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interface, $forMainWorldSuffix, %replacements);
             my $multiLine = ($functionCall =~ tr/\n//) > 1;
             $parameterCheckString .= $multiLine ? " {\n" : "\n";
             $parameterCheckString .= $functionCall;
             $parameterCheckString .= $multiLine ? "    }\n" : "\n";
         }
 
         my $parameterName = $parameter->name;
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         if (IsCallbackInterface($parameter->type)) {
             my $v8ClassName = "V8" . $parameter->type;
             AddToImplIncludes("$v8ClassName.h");
             if ($parameter->isOptional) {
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName;\n";
                 $parameterCheckString .= "    if (args.Length() > $paramIndex && !args[$paramIndex]->IsNull() && !args[$paramIndex]->IsUndefined()) {\n";
                 $parameterCheckString .= "        if (!args[$paramIndex]->IsFunction()) {\n";
                 $parameterCheckString .= "            throwTypeError(args.GetIsolate());\n";
                 $parameterCheckString .= "            return;\n";
@@ skipping 111 matching lines @@
     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}(args);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         $code .= "    if (UNLIKELY(args.Length() < $leastNumMandatoryParams)) {\n";
-        $code .= "        throwNotEnoughArgumentsError(args.GetIsolate());\n";
+
+        $code .= "        throwTypeError(ExceptionMessages::failedToConstruct(\"$implClassName\", \"$leastNumMandatoryParams argument" . ($leastNumMandatoryParams > 1 ? "s" : "")  . " required, but only \" + String::number(args.Length()) + \" present.\"), args.GetIsolate());\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     $code .= <<END;
     throwTypeError(args.GetIsolate());
     return;
 END
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
@@ skipping 21 matching lines @@
     $code .= <<END;
 static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 END
 
     if ($function->overloadedIndex == 0) {
         $code .= GenerateArgumentsCountCheck($function, $interface);
     }
 
     if ($raisesExceptions) {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(args.GetIsolate());\n";
     }
 
     # FIXME: Currently [Constructor(...)] does not yet support optional arguments without [Default=...]
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, "");
     $code .= $parameterCheckString;
 
     if ($interface->extendedAttributes->{"ConstructorCallWith"}) {
         if ($interface->extendedAttributes->{"ConstructorCallWith"} eq "ScriptExecutionContext") {
@@ skipping 114 matching lines @@
     foreach my $attribute (@{$interface->attributes}) {
         if ($attribute->type eq "any") {
             push(@anyAttributeNames, $attribute->name);
             if (!$attribute->extendedAttributes->{"Unserializable"}) {
                 push(@serializableAnyAttributeNames, $attribute->name);
             }
         }
     }
 
     AddToImplIncludes("bindings/v8/Dictionary.h");
+    AddToImplIncludes("bindings/v8/ExceptionMessages.h");
     $implementation{nameSpaceInternal}->add(<<END);
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     if (args.Length() < 1) {
-        throwNotEnoughArgumentsError(args.GetIsolate());
+        throwTypeError(ExceptionMessages::failedToConstruct("$implClassName", "An event name must be provided."), args.GetIsolate());
         return;
     }
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, args[0]);
 END
 
     foreach my $attrName (@anyAttributeNames) {
         $implementation{nameSpaceInternal}->add("    v8::Local<v8::Value> ${attrName};\n");
     }
 
@@ skipping 130 matching lines @@
 
     // 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, args.Holder(), args.GetIsolate());
 
 END
 
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($raisesExceptions) {
+        AddToImplIncludes("bindings/v8/ExceptionMessages.h");
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(args.GetIsolate());\n";
     }
 
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface);
     $code .= $parameterCheckString;
 
     push(@beforeArgumentList, "*document");
 
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
@@ skipping 3185 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;