Skip expensive hasInstance() type-checks in overloads

Source/bindings/tests/results/core/V8TestObject.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
 
 #include "config.h"
 #include "V8TestObject.h"
 
 #include "bindings/core/v8/BindingSecurity.h"
@@ skipping 6774 matching lines @@
     impl->voidMethodDictionarySequenceArg(dictionarySequenceArg);
 }
 
 static void voidMethodDictionarySequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::voidMethodDictionarySequenceArgMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedPromiseMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedPromiseMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPromiseMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_PROMISE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState, info, ScriptState::current(info.GetIsolate()));
     }
     v8SetReturnValue(info, impl->overloadedPromiseMethod(arg).v8Value());
 }
 
-static void overloadedPromiseMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedPromiseMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPromiseMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> arg;
     {
         TOSTRING_VOID_EXCEPTIONSTATE_PROMISE_INTERNAL(arg, info[0], exceptionState, info, ScriptState::current(info.GetIsolate()));
     }
     v8SetReturnValue(info, impl->overloadedPromiseMethod(arg).v8Value());
 }
 
 static void overloadedPromiseMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPromiseMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (info[0]->IsNumber()) {
-            overloadedPromiseMethod1Method(info);
+            overloadedPromiseMethod1Method(info, 0);
             return;
         }
         if (true) {
-            overloadedPromiseMethod2Method(info);
+            overloadedPromiseMethod2Method(info, -1);
             return;
         }
         if (true) {
-            overloadedPromiseMethod1Method(info);
+            overloadedPromiseMethod1Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
@@ skipping 652 matching lines @@
     impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestInterfaceWillBeGarbageCollectedArg);
 }
 
 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodA", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodA(longArg);
 }
 
-static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodA", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg1;
     int longArg2;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg1, toInt32(info[0], exceptionState), exceptionState);
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg2, toInt32(info[1], exceptionState), exceptionState);
     }
     impl->overloadedMethodA(longArg1, longArg2);
 }
 
 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodA", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(2, info.Length())) {
     case 1:
         if (true) {
-            overloadedMethodA1Method(info);
+            overloadedMethodA1Method(info, -1);
             return;
         }
         break;
     case 2:
         if (true) {
-            overloadedMethodA2Method(info);
+            overloadedMethodA2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodAMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodB", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodB(longArg);
 }
 
-static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodB", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> stringArg;
     int longArg;
     {
         TOSTRING_VOID_INTERNAL(stringArg, info[0]);
         if (UNLIKELY(info.Length() <= 1)) {
             impl->overloadedMethodB(stringArg);
             return;
         }
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[1], exceptionState), exceptionState);
     }
     impl->overloadedMethodB(stringArg, longArg);
 }
 
 static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodB", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(2, info.Length())) {
     case 1:
         if (info[0]->IsNumber()) {
-            overloadedMethodB1Method(info);
+            overloadedMethodB1Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodB2Method(info);
+            overloadedMethodB2Method(info, -1);
             return;
         }
         if (true) {
-            overloadedMethodB1Method(info);
+            overloadedMethodB1Method(info, -1);
             return;
         }
         break;
     case 2:
         if (true) {
-            overloadedMethodB2Method(info);
+            overloadedMethodB2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodBMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodC", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodC(longArg);
 }
 
-static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceEmpty* testInterfaceEmptyArg;
     {
-        testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (type_checked_argument_index == 0)
+            testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     }
     impl->overloadedMethodC(testInterfaceEmptyArg);
 }
 
 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodC", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
-            overloadedMethodC2Method(info);
+            overloadedMethodC2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodC1Method(info);
+            overloadedMethodC1Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodCMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodD", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodD(longArg);
 }
 
-static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodD", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     Vector<int> longArrayArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArrayArg, toImplArray<int>(info[0], 1, info.GetIsolate(), exceptionState), exceptionState);
     }
     impl->overloadedMethodD(longArrayArg);
 }
 
 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodD", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (info[0]->IsArray()) {
-            overloadedMethodD2Method(info);
+            overloadedMethodD2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodD1Method(info);
+            overloadedMethodD1Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodDMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodE", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodE(longArg);
 }
 
-static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
     {
-        testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (type_checked_argument_index == 0)
+            testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     }
     impl->overloadedMethodE(testInterfaceEmptyOrNullArg);
 }
 
 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodE", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (isUndefinedOrNull(info[0])) {
-            overloadedMethodE2Method(info);
+            overloadedMethodE2Method(info, -1);
             return;
         }
         if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
-            overloadedMethodE2Method(info);
+            overloadedMethodE2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodE1Method(info);
+            overloadedMethodE1Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodEMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> stringArg;
     {
         if (UNLIKELY(info.Length() <= 0)) {
             impl->overloadedMethodF();
             return;
         }
         TOSTRING_VOID_INTERNAL(stringArg, info[0]);
     }
     impl->overloadedMethodF(stringArg);
 }
 
-static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodF", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     double doubleArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(doubleArg, toDouble(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodF(doubleArg);
 }
 
 static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodF", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            overloadedMethodF1Method(info);
+            overloadedMethodF1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (info[0]->IsUndefined()) {
-            overloadedMethodF1Method(info);
+            overloadedMethodF1Method(info, -1);
             return;
         }
         if (info[0]->IsNumber()) {
-            overloadedMethodF2Method(info);
+            overloadedMethodF2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodF1Method(info);
+            overloadedMethodF1Method(info, -1);
             return;
         }
         if (true) {
-            overloadedMethodF2Method(info);
+            overloadedMethodF2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodFMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodFMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodG1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodG1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodG", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodG(longArg);
 }
 
-static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
     {
         if (!info[0]->IsUndefined()) {
-            testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+            if (type_checked_argument_index == 0)
+                testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+            else
+                testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
         } else {
             testInterfaceEmptyOrNullArg = nullptr;
         }
     }
     impl->overloadedMethodG(testInterfaceEmptyOrNullArg);
 }
 
 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodG", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            overloadedMethodG2Method(info);
+            overloadedMethodG2Method(info, -1);
             return;
         }
         break;
     case 1:
         if (info[0]->IsUndefined()) {
-            overloadedMethodG2Method(info);
+            overloadedMethodG2Method(info, -1);
             return;
         }
         if (isUndefinedOrNull(info[0])) {
-            overloadedMethodG2Method(info);
+            overloadedMethodG2Method(info, -1);
             return;
         }
         if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
-            overloadedMethodG2Method(info);
+            overloadedMethodG2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodG1Method(info);
+            overloadedMethodG1Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodGMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodGMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceImplementation* testInterfaceArg;
     {
-        testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (type_checked_argument_index == 0)
+            testInterfaceArg = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     }
     impl->overloadedMethodH(testInterfaceArg);
 }
 
-static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceEmpty* testInterfaceEmptyArg;
     {
-        testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (type_checked_argument_index == 0)
+            testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     }
     impl->overloadedMethodH(testInterfaceEmptyArg);
 }
 
 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodH", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) {
-            overloadedMethodH1Method(info);
+            overloadedMethodH1Method(info, 0);
             return;
         }
         if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
-            overloadedMethodH2Method(info);
+            overloadedMethodH2Method(info, 0);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodHMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodHMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodI1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodI1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> stringArg;
     {
         TOSTRING_VOID_INTERNAL(stringArg, info[0]);
     }
     impl->overloadedMethodI(stringArg);
 }
 
-static void overloadedMethodI2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodI2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodI", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     double doubleArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(doubleArg, toDouble(info[0], exceptionState), exceptionState);
     }
     impl->overloadedMethodI(doubleArg);
 }
 
 static void overloadedMethodIMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodI", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (info[0]->IsNumber()) {
-            overloadedMethodI2Method(info);
+            overloadedMethodI2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodI1Method(info);
+            overloadedMethodI1Method(info, -1);
             return;
         }
         if (true) {
-            overloadedMethodI2Method(info);
+            overloadedMethodI2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodIMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodIMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedMethodJ1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodJ1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> stringArg;
     {
         TOSTRING_VOID_INTERNAL(stringArg, info[0]);
     }
     impl->overloadedMethodJ(stringArg);
 }
 
-static void overloadedMethodJ2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedMethodJ2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodJ", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestDictionary* testDictionaryArg;
     {
         if (!info[0]->IsUndefined()) {
             if (!isUndefinedOrNull(info[0]) && !info[0]->IsObject()) {
                 exceptionState.throwTypeError("parameter 1 ('testDictionaryArg') is not an object.");
                 exceptionState.throwIfNeeded();
                 return;
             }
             TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(testDictionaryArg, V8TestDictionary::toImpl(info.GetIsolate(), info[0], exceptionState), exceptionState);
         } else {
             testDictionaryArg = TestDictionary::create();
         }
     }
     impl->overloadedMethodJ(*testDictionaryArg);
 }
 
 static void overloadedMethodJMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodJ", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (info[0]->IsObject()) {
-            overloadedMethodJ2Method(info);
+            overloadedMethodJ2Method(info, 0);
             return;
         }
         if (true) {
-            overloadedMethodJ1Method(info);
+            overloadedMethodJ1Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedMethodJMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedMethodJMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedPerWorldBindingsMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedPerWorldBindingsMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->overloadedPerWorldBindingsMethod();
 }
 
-static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->overloadedPerWorldBindingsMethod();
 }
 
-static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPerWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedPerWorldBindingsMethod(longArg);
 }
 
 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPerWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            overloadedPerWorldBindingsMethod1Method(info);
+            overloadedPerWorldBindingsMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
-            overloadedPerWorldBindingsMethod2Method(info);
+            overloadedPerWorldBindingsMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedPerWorldBindingsMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPerWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->overloadedPerWorldBindingsMethod(longArg);
 }
 
 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPerWorldBindingsMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            overloadedPerWorldBindingsMethod1MethodForMainWorld(info);
+            overloadedPerWorldBindingsMethod1MethodForMainWorld(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
-            overloadedPerWorldBindingsMethod2MethodForMainWorld(info);
+            overloadedPerWorldBindingsMethod2MethodForMainWorld(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::overloadedPerWorldBindingsMethodMethodForMainWorld(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedStaticMethod", "TestObject", info.Holder(), info.GetIsolate());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     TestObject::overloadedStaticMethod(longArg);
 }
 
-static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedStaticMethod", "TestObject", info.Holder(), info.GetIsolate());
     int longArg1;
     int longArg2;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg1, toInt32(info[0], exceptionState), exceptionState);
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg2, toInt32(info[1], exceptionState), exceptionState);
     }
     TestObject::overloadedStaticMethod(longArg1, longArg2);
 }
 
 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedStaticMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(2, info.Length())) {
     case 1:
         if (true) {
-            overloadedStaticMethod1Method(info);
+            overloadedStaticMethod1Method(info, -1);
             return;
         }
         break;
     case 2:
         if (true) {
-            overloadedStaticMethod2Method(info);
+            overloadedStaticMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
@@ skipping 462 matching lines @@
 }
 
 static void measureAsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
     TestObjectV8Internal::measureAsVoidMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void DeprecateAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void DeprecateAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->DeprecateAsOverloadedMethod();
 }
 
-static void DeprecateAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void DeprecateAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->DeprecateAsOverloadedMethod(arg);
 }
 
 static void DeprecateAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
-            DeprecateAsOverloadedMethod1Method(info);
+            DeprecateAsOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
             UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureB);
-            DeprecateAsOverloadedMethod2Method(info);
+            DeprecateAsOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void DeprecateAsOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::DeprecateAsOverloadedMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void DeprecateAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void DeprecateAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->DeprecateAsSameValueOverloadedMethod();
 }
 
-static void DeprecateAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void DeprecateAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->DeprecateAsSameValueOverloadedMethod(arg);
 }
 
 static void DeprecateAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "DeprecateAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            DeprecateAsSameValueOverloadedMethod1Method(info);
+            DeprecateAsSameValueOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
-            DeprecateAsSameValueOverloadedMethod2Method(info);
+            DeprecateAsSameValueOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void DeprecateAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::DeprecateAsSameValueOverloadedMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void measureAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void measureAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->measureAsOverloadedMethod();
 }
 
-static void measureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void measureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->measureAsOverloadedMethod(arg);
 }
 
 static void measureAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
-            measureAsOverloadedMethod1Method(info);
+            measureAsOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
             UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureB);
-            measureAsOverloadedMethod2Method(info);
+            measureAsOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void measureAsOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::measureAsOverloadedMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void measureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void measureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->measureAsSameValueOverloadedMethod();
 }
 
-static void measureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void measureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->measureAsSameValueOverloadedMethod(arg);
 }
 
 static void measureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "measureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            measureAsSameValueOverloadedMethod1Method(info);
+            measureAsSameValueOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
-            measureAsSameValueOverloadedMethod2Method(info);
+            measureAsSameValueOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void measureAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::measureAsSameValueOverloadedMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void deprecateAsMeasureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void deprecateAsMeasureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->deprecateAsMeasureAsSameValueOverloadedMethod();
 }
 
-static void deprecateAsMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void deprecateAsMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAsMeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->deprecateAsMeasureAsSameValueOverloadedMethod(arg);
 }
 
 static void deprecateAsMeasureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAsMeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
-            deprecateAsMeasureAsSameValueOverloadedMethod1Method(info);
+            deprecateAsMeasureAsSameValueOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
             UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureB);
-            deprecateAsMeasureAsSameValueOverloadedMethod2Method(info);
+            deprecateAsMeasureAsSameValueOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void deprecateAsMeasureAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::deprecateAsMeasureAsSameValueOverloadedMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void deprecateAsSameValueMeasureAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void deprecateAsSameValueMeasureAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->deprecateAsSameValueMeasureAsOverloadedMethod();
 }
 
-static void deprecateAsSameValueMeasureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void deprecateAsSameValueMeasureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAsSameValueMeasureAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->deprecateAsSameValueMeasureAsOverloadedMethod(arg);
 }
 
 static void deprecateAsSameValueMeasureAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAsSameValueMeasureAsOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
             UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
-            deprecateAsSameValueMeasureAsOverloadedMethod1Method(info);
+            deprecateAsSameValueMeasureAsOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
             UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureB);
-            deprecateAsSameValueMeasureAsOverloadedMethod2Method(info);
+            deprecateAsSameValueMeasureAsOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void deprecateAsSameValueMeasureAsOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::deprecateAsSameValueMeasureAsOverloadedMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod();
 }
 
-static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAsSameValueMeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int arg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(arg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod(arg);
 }
 
 static void deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "deprecateAsSameValueMeasureAsSameValueOverloadedMethod", "TestObject", info.Holder(), info.GetIsolate());
     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureB);
     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeatureA);
     switch (std::min(1, info.Length())) {
     case 0:
         if (true) {
-            deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(info);
+            deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(info, -1);
             return;
         }
         break;
     case 1:
         if (true) {
-            deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(info);
+            deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
@@ skipping 382 matching lines @@
     impl->perWorldBindingsRuntimeEnabledVoidMethod();
 }
 
 static void perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodForMainWorld(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void runtimeEnabledOverloadedVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void runtimeEnabledOverloadedVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> stringArg;
     {
         TOSTRING_VOID_INTERNAL(stringArg, info[0]);
     }
     impl->runtimeEnabledOverloadedVoidMethod(stringArg);
 }
 
-static void runtimeEnabledOverloadedVoidMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void runtimeEnabledOverloadedVoidMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "runtimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->runtimeEnabledOverloadedVoidMethod(longArg);
 }
 
 static void runtimeEnabledOverloadedVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "runtimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (info[0]->IsNumber()) {
-            runtimeEnabledOverloadedVoidMethod2Method(info);
+            runtimeEnabledOverloadedVoidMethod2Method(info, 0);
             return;
         }
         if (true) {
-            runtimeEnabledOverloadedVoidMethod1Method(info);
+            runtimeEnabledOverloadedVoidMethod1Method(info, -1);
             return;
         }
         if (true) {
-            runtimeEnabledOverloadedVoidMethod2Method(info);
+            runtimeEnabledOverloadedVoidMethod2Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
 }
 
 static void runtimeEnabledOverloadedVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::runtimeEnabledOverloadedVoidMethodMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
-static void partiallyRuntimeEnabledOverloadedVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void partiallyRuntimeEnabledOverloadedVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     V8StringResource<> stringArg;
     {
         TOSTRING_VOID_INTERNAL(stringArg, info[0]);
     }
     impl->partiallyRuntimeEnabledOverloadedVoidMethod(stringArg);
 }
 
-static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceImplementation* testInterface;
     {
-        testInterface = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (type_checked_argument_index == 0)
+            testInterface = V8TestInterface::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            testInterface = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     }
     impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterface);
 }
 
-static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::FunctionCallbackInfo<v8::Value>& info)
+static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "partiallyRuntimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     int longArg;
     {
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(longArg, toInt32(info[0], exceptionState), exceptionState);
     }
     impl->partiallyRuntimeEnabledOverloadedVoidMethod(longArg);
 }
 
 static void partiallyRuntimeEnabledOverloadedVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "partiallyRuntimeEnabledOverloadedVoidMethod", "TestObject", info.Holder(), info.GetIsolate());
     switch (std::min(1, info.Length())) {
     case 1:
         if (RuntimeEnabledFeatures::featureName2Enabled()) {
             if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) {
-                partiallyRuntimeEnabledOverloadedVoidMethod2Method(info);
+                partiallyRuntimeEnabledOverloadedVoidMethod2Method(info, 0);
                 return;
             }
         }
         if (info[0]->IsNumber()) {
-            partiallyRuntimeEnabledOverloadedVoidMethod3Method(info);
+            partiallyRuntimeEnabledOverloadedVoidMethod3Method(info, 0);
             return;
         }
         if (RuntimeEnabledFeatures::featureName1Enabled()) {
             if (true) {
-                partiallyRuntimeEnabledOverloadedVoidMethod1Method(info);
+                partiallyRuntimeEnabledOverloadedVoidMethod1Method(info, -1);
                 return;
             }
         }
         if (true) {
-            partiallyRuntimeEnabledOverloadedVoidMethod3Method(info);
+            partiallyRuntimeEnabledOverloadedVoidMethod3Method(info, -1);
             return;
         }
         break;
     default:
         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
         exceptionState.throwIfNeeded();
         return;
     }
     exceptionState.throwTypeError("No function was found that matched the signature provided.");
     exceptionState.throwIfNeeded();
@@ skipping 90 matching lines @@
         V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", 1, info.Length(), info.GetIsolate()), info.GetIsolate());
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     TestInterfaceEmpty* testInterfaceEmptyArg;
     {
         if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
             return;
         }
-        testInterfaceEmptyArg = V8TestInterfaceEmpty::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     }
     impl->typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
 }
 
 static void typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
@@ skipping 30 matching lines @@
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     Node* node1;
     Node* node2;
     {
         if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
             return;
         }
-        node1 = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        node1 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
         if (UNLIKELY(info.Length() <= 1)) {
             impl->useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg(node1);
             return;
         }
         if (info.Length() > 1 && !V8Node::hasInstance(info[1], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
             return;
         }
-        node2 = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[1]));
+        node2 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
     }
     impl->useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg(node1, node2);
 }
 
 static void useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
 static void useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (UNLIKELY(info.Length() < 2)) {
         V8ThrowException::throwException(createMinimumArityTypeErrorForMethod("useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", "TestObject", 2, info.Length(), info.GetIsolate()), info.GetIsolate());
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     Node* node1;
     Node* node2;
     {
         if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
             return;
         }
-        node1 = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        node1 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
         if (info.Length() > 1 && !isUndefinedOrNull(info[1]) && !V8Node::hasInstance(info[1], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
             return;
         }
         node2 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
     }
     impl->useToImpl4ArgumentsCheckingIfPossibleWithNullableArg(node1, node2);
 }
 
 static void useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 10 matching lines @@
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     Node* node1;
     Node* node2;
     {
         if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
             return;
         }
-        node1 = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        node1 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
         if (info.Length() > 1 && !V8Node::hasInstance(info[1], info.GetIsolate())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
             return;
         }
         node2 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
     }
     impl->useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg(node1, node2);
 }
 
 static void useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
     TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethod(info);
     TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
 }
 
+static void typeCheckingMaybeRedundantForOverloadingMethodsA1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsA", "TestObject", info.Holder(), info.GetIsolate());
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    int b;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {

[Jens Widell, 2014/10/14 12:13:44]

In the context of this CL, please ignore this hasInstance(). It would be dealt
with otherwise.

+            exceptionState.throwTypeError("parameter 1 is not of type 'Node'.");
+            exceptionState.throwIfNeeded();
+            return;
+        }
+        if (type_checked_argument_index == 0)
+            a = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsA(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsA2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsA", "TestObject", info.Holder(), info.GetIsolate());
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    int a;
+    int b;
+    {
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(a, toInt32(info[0], exceptionState), exceptionState);
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsA(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsAMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsA", "TestObject", info.Holder(), info.GetIsolate());
+    switch (std::min(2, info.Length())) {
+    case 2:
+        if (V8Node::hasInstance(info[0], info.GetIsolate())) {
+            typeCheckingMaybeRedundantForOverloadingMethodsA1Method(info, 0);
+            return;
+        }
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsA2Method(info, -1);
+            return;
+        }
+        break;
+    default:
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No function was found that matched the signature provided.");
+    exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsAMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+    TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsAMethod(info);
+    TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsB1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsB", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsB(a);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsB2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsB", "TestObject", info.Holder(), info.GetIsolate());
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    int a;
+    int b;
+    {
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(a, toInt32(info[0], exceptionState), exceptionState);
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsB(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsBMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsB", "TestObject", info.Holder(), info.GetIsolate());
+    switch (std::min(2, info.Length())) {
+    case 1:
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsB1Method(info, -1);
+            return;
+        }
+        break;
+    case 2:
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsB2Method(info, -1);
+            return;
+        }
+        break;
+    default:
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No function was found that matched the signature provided.");
+    exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsBMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+    TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsBMethod(info);
+    TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsC1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsC", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        if (type_checked_argument_index == 0)
+            a = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsC(a);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsC2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsC", "TestObject", info.Holder(), info.GetIsolate());
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    int a;
+    int b;
+    {
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(a, toInt32(info[0], exceptionState), exceptionState);
+        if (UNLIKELY(info.Length() <= 1)) {
+            impl->typeCheckingMaybeRedundantForOverloadingMethodsC(a);
+            return;
+        }
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsC(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsCMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsC", "TestObject", info.Holder(), info.GetIsolate());
+    switch (std::min(2, info.Length())) {
+    case 1:
+        if (V8Node::hasInstance(info[0], info.GetIsolate())) {
+            typeCheckingMaybeRedundantForOverloadingMethodsC1Method(info, 0);
+            return;
+        }
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsC2Method(info, -1);
+            return;
+        }
+        break;
+    case 2:
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsC2Method(info, -1);
+            return;
+        }
+        break;
+    default:
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No function was found that matched the signature provided.");
+    exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsCMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+    TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsCMethod(info);
+    TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsD1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    Node* b;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (info.Length() > 1 && !V8Node::hasInstance(info[1], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        if (type_checked_argument_index == 1)
+            b = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[1]));
+        else
+            b = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsD(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsD2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", info.Holder(), info.GetIsolate());
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    int b;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            exceptionState.throwTypeError("parameter 1 is not of type 'Node'.");
+            exceptionState.throwIfNeeded();
+            return;
+        }
+        a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsD(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsDMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsD", "TestObject", info.Holder(), info.GetIsolate());
+    switch (std::min(2, info.Length())) {
+    case 2:
+        if (V8Node::hasInstance(info[1], info.GetIsolate())) {
+            typeCheckingMaybeRedundantForOverloadingMethodsD1Method(info, 1);
+            return;
+        }
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsD2Method(info, -1);
+            return;
+        }
+        break;
+    default:
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No function was found that matched the signature provided.");
+    exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsDMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+    TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsDMethod(info);
+    TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsE1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    Node* b;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (info.Length() > 1 && !V8Node::hasInstance(info[1], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        if (type_checked_argument_index == 1)
+            b = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[1]));
+        else
+            b = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsE(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsE2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", info.Holder(), info.GetIsolate());
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    int b;
+    {
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            exceptionState.throwTypeError("parameter 1 is not of type 'Node'.");
+            exceptionState.throwIfNeeded();
+            return;
+        }
+        a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (UNLIKELY(info.Length() <= 1)) {
+            impl->typeCheckingMaybeRedundantForOverloadingMethodsE(a);
+            return;
+        }
+        TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(b, toInt32(info[1], exceptionState), exceptionState);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsE(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsEMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsE", "TestObject", info.Holder(), info.GetIsolate());
+    switch (std::min(2, info.Length())) {
+    case 1:
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsE2Method(info, -1);
+            return;
+        }
+        break;
+    case 2:
+        if (info[1]->IsUndefined()) {
+            typeCheckingMaybeRedundantForOverloadingMethodsE2Method(info, -1);
+            return;
+        }
+        if (V8Node::hasInstance(info[1], info.GetIsolate())) {
+            typeCheckingMaybeRedundantForOverloadingMethodsE1Method(info, 1);
+            return;
+        }
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsE2Method(info, -1);
+            return;
+        }
+        break;
+    default:
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No function was found that matched the signature provided.");
+    exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsEMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+    TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsEMethod(info);
+    TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsF1Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Node* a;
+    {
+        if (UNLIKELY(info.Length() <= 0)) {
+            impl->typeCheckingMaybeRedundantForOverloadingMethodsF();
+            return;
+        }
+        if (info.Length() > 0 && !V8Node::hasInstance(info[0], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", "parameter 1 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        if (type_checked_argument_index == 0)
+            a = V8Node::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            a = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsF(a);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsF2Method(const v8::FunctionCallbackInfo<v8::Value>& info, int type_checked_argument_index)
+{
+    TestObject* impl = V8TestObject::toImpl(info.Holder());
+    Document* a;
+    Node* b;
+    {
+        if (info.Length() > 0 && !V8Document::hasInstance(info[0], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", "parameter 1 is not of type 'Document'."), info.GetIsolate());
+            return;
+        }
+        if (type_checked_argument_index == 0)
+            a = V8Document::toImpl(v8::Handle<v8::Object>::Cast(info[0]));
+        else
+            a = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);
+        if (UNLIKELY(info.Length() <= 1)) {
+            impl->typeCheckingMaybeRedundantForOverloadingMethodsF(a);
+            return;
+        }
+        if (info.Length() > 1 && !V8Node::hasInstance(info[1], info.GetIsolate())) {
+            V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", "parameter 2 is not of type 'Node'."), info.GetIsolate());
+            return;
+        }
+        b = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
+    }
+    impl->typeCheckingMaybeRedundantForOverloadingMethodsF(a, b);
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsFMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingMaybeRedundantForOverloadingMethodsF", "TestObject", info.Holder(), info.GetIsolate());
+    switch (std::min(2, info.Length())) {
+    case 0:
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsF1Method(info, -1);
+            return;
+        }
+        break;
+    case 1:
+        if (info[0]->IsUndefined()) {
+            typeCheckingMaybeRedundantForOverloadingMethodsF1Method(info, -1);
+            return;
+        }
+        if (V8Node::hasInstance(info[0], info.GetIsolate())) {
+            typeCheckingMaybeRedundantForOverloadingMethodsF1Method(info, 0);
+            return;
+        }
+        if (V8Document::hasInstance(info[0], info.GetIsolate())) {
+            typeCheckingMaybeRedundantForOverloadingMethodsF2Method(info, 0);
+            return;
+        }
+        break;
+    case 2:
+        if (true) {
+            typeCheckingMaybeRedundantForOverloadingMethodsF2Method(info, -1);
+            return;
+        }
+        break;
+    default:
+        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(0, info.Length()));
+        exceptionState.throwIfNeeded();
+        return;
+    }
+    exceptionState.throwTypeError("No function was found that matched the signature provided.");
+    exceptionState.throwIfNeeded();
+}
+
+static void typeCheckingMaybeRedundantForOverloadingMethodsFMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMMethod");
+    TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsFMethod(info);
+    TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
+}
+
 static void typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg", "TestObject", info.Holder(), info.GetIsolate());
     if (UNLIKELY(info.Length() < 2)) {
         setMinimumArityTypeError(exceptionState, 2, info.Length());
         exceptionState.throwIfNeeded();
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
     float floatArg;
@@ skipping 658 matching lines @@
     {"treatReturnedNullStringAsUndefinedStringMethod", TestObjectV8Internal::treatReturnedNullStringAsUndefinedStringMethodMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"treatReturnedNullStringAsNullByteStringMethod", TestObjectV8Internal::treatReturnedNullStringAsNullByteStringMethodMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"treatReturnedNullStringAsUndefinedByteStringMethod", TestObjectV8Internal::treatReturnedNullStringAsUndefinedByteStringMethodMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"treatReturnedNullStringAsNullScalarValueStringMethod", TestObjectV8Internal::treatReturnedNullStringAsNullScalarValueStringMethodMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"treatReturnedNullStringAsUndefinedScalarValueStringMethod", TestObjectV8Internal::treatReturnedNullStringAsUndefinedScalarValueStringMethodMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"typeCheckingInterfaceVoidMethodTestInterfaceEmptyArg", TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArg", TestObjectV8Internal::typeCheckingInterfaceVoidMethodTestInterfaceEmptyVariadicArgMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethodCallback, 0, 2, V8DOMConfiguration::ExposedToAllScripts},
     {"useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+    {"typeCheckingMaybeRedundantForOverloadingMethodsA", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsAMethodCallback, 0, 2, V8DOMConfiguration::ExposedToAllScripts},
+    {"typeCheckingMaybeRedundantForOverloadingMethodsB", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsBMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+    {"typeCheckingMaybeRedundantForOverloadingMethodsC", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsCMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+    {"typeCheckingMaybeRedundantForOverloadingMethodsD", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsDMethodCallback, 0, 2, V8DOMConfiguration::ExposedToAllScripts},
+    {"typeCheckingMaybeRedundantForOverloadingMethodsE", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsEMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
+    {"typeCheckingMaybeRedundantForOverloadingMethodsF", TestObjectV8Internal::typeCheckingMaybeRedundantForOverloadingMethodsFMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"typeCheckingUnrestrictedVoidMethodFloatArgDoubleArg", TestObjectV8Internal::typeCheckingUnrestrictedVoidMethodFloatArgDoubleArgMethodCallback, 0, 2, V8DOMConfiguration::ExposedToAllScripts},
     {"voidMethodTestInterfaceGarbageCollectedSequenceArg", TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"voidMethodTestInterfaceGarbageCollectedArrayArg", TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg", TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"voidMethodTestInterfaceWillBeGarbageCollectedArrayArg", TestObjectV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"voidMethodImplementedInPrivateScript", TestObjectV8Internal::voidMethodImplementedInPrivateScriptMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"shortMethodImplementedInPrivateScript", TestObjectV8Internal::shortMethodImplementedInPrivateScriptMethodCallback, 0, 0, V8DOMConfiguration::ExposedToAllScripts},
     {"shortMethodWithShortArgumentImplementedInPrivateScript", TestObjectV8Internal::shortMethodWithShortArgumentImplementedInPrivateScriptMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"stringMethodWithStringArgumentImplementedInPrivateScript", TestObjectV8Internal::stringMethodWithStringArgumentImplementedInPrivateScriptMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
     {"nodeMethodWithNodeArgumentImplementedInPrivateScript", TestObjectV8Internal::nodeMethodWithNodeArgumentImplementedInPrivateScriptMethodCallback, 0, 1, V8DOMConfiguration::ExposedToAllScripts},
@@ skipping 666 matching lines @@
         return false;
 
     ScriptState::Scope scope(scriptState);
     v8::Handle<v8::Value> holder = toV8(holderImpl, scriptState->context()->Global(), scriptState->isolate());
 
     ExceptionState exceptionState(ExceptionState::SetterContext, "enumForPrivateScript", "TestObject", scriptState->context()->Global(), scriptState->isolate());
     return PrivateScriptRunner::runDOMAttributeSetter(scriptState, scriptStateInUserScript, "TestObject", "enumForPrivateScript", holder, v8String(scriptState->isolate(), cppValue));
 }
 
 } // namespace blink