IDL: Drop value conversion (V8 -> C++) macros from generated code

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

Index: Source/bindings/tests/results/core/V8TestDictionary.cpp
diff --git a/Source/bindings/tests/results/core/V8TestDictionary.cpp b/Source/bindings/tests/results/core/V8TestDictionary.cpp
index 70e599ef997c57c070221fdb26795c9dcac46c96..f61cffe8f839fb3dbeb1ea83dac85423d2a22cda 100644
--- a/Source/bindings/tests/results/core/V8TestDictionary.cpp
+++ b/Source/bindings/tests/results/core/V8TestDictionary.cpp
@@ -22,13 +22,13 @@
 
 namespace blink {
 
-void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
+bool V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestDictionary& impl, ExceptionState& exceptionState)
 {
     if (isUndefinedOrNull(v8Value))
-        return;
+        return true;
     if (!v8Value->IsObject()) {
         exceptionState.throwTypeError("cannot convert to dictionary.");
-        return;
+        return false;
     }
 
     v8::Local<v8::Object> v8Object = v8Value->ToObject(isolate);
@@ -36,7 +36,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> booleanMemberValue = v8Object->Get(v8String(isolate, "booleanMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (booleanMemberValue.IsEmpty() || booleanMemberValue->IsUndefined()) {
         // Do nothing.
@@ -48,7 +48,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> createValue = v8Object->Get(v8String(isolate, "create"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (createValue.IsEmpty() || createValue->IsUndefined()) {
         // Do nothing.
@@ -60,7 +60,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> deprecatedCreateMemberValue = v8Object->Get(v8String(isolate, "deprecatedCreateMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (deprecatedCreateMemberValue.IsEmpty() || deprecatedCreateMemberValue->IsUndefined()) {
         // Do nothing.
@@ -73,34 +73,33 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> doubleOrNullMemberValue = v8Object->Get(v8String(isolate, "doubleOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (doubleOrNullMemberValue.IsEmpty() || doubleOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (doubleOrNullMemberValue->IsNull()) {
         impl.setDoubleOrNullMemberToNull();
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(double, doubleOrNullMember, toDouble(doubleOrNullMemberValue, exceptionState), exceptionState);
+        TONATIVE_DECLARE(double, doubleOrNullMember, convertAndCheck(doubleOrNullMember = toDouble(doubleOrNullMemberValue, exceptionState), exceptionState), return false);
         impl.setDoubleOrNullMember(doubleOrNullMember);
     }
 
     v8::Local<v8::Value> doubleOrStringMemberValue = v8Object->Get(v8String(isolate, "doubleOrStringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (doubleOrStringMemberValue.IsEmpty() || doubleOrStringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        DoubleOrString doubleOrStringMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), exceptionState);
+        TONATIVE_DECLARE(DoubleOrString, doubleOrStringMember, V8DoubleOrString::toImpl(isolate, doubleOrStringMemberValue, doubleOrStringMember, exceptionState), return false);
         impl.setDoubleOrStringMember(doubleOrStringMember);
     }
 
     v8::Local<v8::Value> elementOrNullMemberValue = v8Object->Get(v8String(isolate, "elementOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (elementOrNullMemberValue.IsEmpty() || elementOrNullMemberValue->IsUndefined()) {
         // Do nothing.
@@ -110,7 +109,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         Element* elementOrNullMember = V8Element::toImplWithTypeCheck(isolate, elementOrNullMemberValue);
         if (!elementOrNullMember && !elementOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member elementOrNullMember is not of type Element.");
-            return;
+            return false;
         }
         impl.setElementOrNullMember(elementOrNullMember);
     }
@@ -118,16 +117,16 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> enumMemberValue = v8Object->Get(v8String(isolate, "enumMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (enumMemberValue.IsEmpty() || enumMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TOSTRING_VOID(V8StringResource<>, enumMember, enumMemberValue);
+        TONATIVE_DECLARE(V8StringResource<>, enumMember, (enumMember = enumMemberValue).prepare(exceptionState), return false);
         String string = enumMember;
         if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
             exceptionState.throwTypeError("member enumMember ('" + string + "') is not a valid enum value.");
-            return;
+            return false;
         }
         impl.setEnumMember(enumMember);
     }
@@ -135,7 +134,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> eventTargetMemberValue = v8Object->Get(v8String(isolate, "eventTargetMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (eventTargetMemberValue.IsEmpty() || eventTargetMemberValue->IsUndefined()) {
         // Do nothing.
@@ -143,7 +142,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         EventTarget* eventTargetMember = toEventTarget(isolate, eventTargetMemberValue);
         if (!eventTargetMember && !eventTargetMemberValue->IsNull()) {
             exceptionState.throwTypeError("member eventTargetMember is not of type EventTarget.");
-            return;
+            return false;
         }
         impl.setEventTargetMember(eventTargetMember);
     }
@@ -151,31 +150,31 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> internalDictionarySequenceMemberValue = v8Object->Get(v8String(isolate, "internalDictionarySequenceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (internalDictionarySequenceMemberValue.IsEmpty() || internalDictionarySequenceMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(Vector<InternalDictionary>, internalDictionarySequenceMember, toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+        TONATIVE_DECLARE(Vector<InternalDictionary>, internalDictionarySequenceMember, convertAndCheck(internalDictionarySequenceMember = toImplArray<InternalDictionary>(internalDictionarySequenceMemberValue, 0, isolate, exceptionState), exceptionState), return false);
         impl.setInternalDictionarySequenceMember(internalDictionarySequenceMember);
     }
 
     v8::Local<v8::Value> longMemberValue = v8Object->Get(v8String(isolate, "longMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (longMemberValue.IsEmpty() || longMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(int, longMember, toInt32(longMemberValue, exceptionState), exceptionState);
+        TONATIVE_DECLARE(int, longMember, convertAndCheck(longMember = toInt32(longMemberValue, exceptionState), exceptionState), return false);
         impl.setLongMember(longMember);
     }
 
     v8::Local<v8::Value> objectMemberValue = v8Object->Get(v8String(isolate, "objectMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (objectMemberValue.IsEmpty() || objectMemberValue->IsUndefined()) {
         // Do nothing.
@@ -183,7 +182,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         ScriptValue objectMember = ScriptValue(ScriptState::current(isolate), objectMemberValue);
         if (!objectMember.isObject()) {
             exceptionState.throwTypeError("member objectMember is not an object.");
-            return;
+            return false;
         }
         impl.setObjectMember(objectMember);
     }
@@ -191,7 +190,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> objectOrNullMemberValue = v8Object->Get(v8String(isolate, "objectOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (objectOrNullMemberValue.IsEmpty() || objectOrNullMemberValue->IsUndefined()) {
         // Do nothing.
@@ -201,7 +200,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         ScriptValue objectOrNullMember = ScriptValue(ScriptState::current(isolate), objectOrNullMemberValue);
         if (!objectOrNullMember.isObject()) {
             exceptionState.throwTypeError("member objectOrNullMember is not an object.");
-            return;
+            return false;
         }
         impl.setObjectOrNullMember(objectOrNullMember);
     }
@@ -209,95 +208,93 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> otherDoubleOrStringMemberValue = v8Object->Get(v8String(isolate, "otherDoubleOrStringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (otherDoubleOrStringMemberValue.IsEmpty() || otherDoubleOrStringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        DoubleOrString otherDoubleOrStringMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState), exceptionState);
+        TONATIVE_DECLARE(DoubleOrString, otherDoubleOrStringMember, V8DoubleOrString::toImpl(isolate, otherDoubleOrStringMemberValue, otherDoubleOrStringMember, exceptionState), return false);
         impl.setOtherDoubleOrStringMember(otherDoubleOrStringMember);
     }
 
     v8::Local<v8::Value> restrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "restrictedDoubleMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (restrictedDoubleMemberValue.IsEmpty() || restrictedDoubleMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(double, restrictedDoubleMember, toRestrictedDouble(restrictedDoubleMemberValue, exceptionState), exceptionState);
+        TONATIVE_DECLARE(double, restrictedDoubleMember, convertAndCheck(restrictedDoubleMember = toRestrictedDouble(restrictedDoubleMemberValue, exceptionState), exceptionState), return false);
         impl.setRestrictedDoubleMember(restrictedDoubleMember);
     }
 
     v8::Local<v8::Value> stringArrayMemberValue = v8Object->Get(v8String(isolate, "stringArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringArrayMemberValue.IsEmpty() || stringArrayMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringArrayMember, toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState);
+        TONATIVE_DECLARE(Vector<String>, stringArrayMember, convertAndCheck(stringArrayMember = toImplArray<String>(stringArrayMemberValue, 0, isolate, exceptionState), exceptionState), return false);
         impl.setStringArrayMember(stringArrayMember);
     }
 
     v8::Local<v8::Value> stringMemberValue = v8Object->Get(v8String(isolate, "stringMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringMemberValue.IsEmpty() || stringMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TOSTRING_VOID(V8StringResource<>, stringMember, stringMemberValue);
+        TONATIVE_DECLARE(V8StringResource<>, stringMember, (stringMember = stringMemberValue).prepare(exceptionState), return false);
         impl.setStringMember(stringMember);
     }
 
     v8::Local<v8::Value> stringOrNullMemberValue = v8Object->Get(v8String(isolate, "stringOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringOrNullMemberValue.IsEmpty() || stringOrNullMemberValue->IsUndefined()) {
         // Do nothing.
     } else if (stringOrNullMemberValue->IsNull()) {
         impl.setStringOrNullMemberToNull();
     } else {
-        TOSTRING_VOID(V8StringResource<>, stringOrNullMember, stringOrNullMemberValue);
+        TONATIVE_DECLARE(V8StringResource<>, stringOrNullMember, (stringOrNullMember = stringOrNullMemberValue).prepare(exceptionState), return false);
         impl.setStringOrNullMember(stringOrNullMember);
     }
 
     v8::Local<v8::Value> stringSequenceMemberValue = v8Object->Get(v8String(isolate, "stringSequenceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (stringSequenceMemberValue.IsEmpty() || stringSequenceMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(Vector<String>, stringSequenceMember, toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState);
+        TONATIVE_DECLARE(Vector<String>, stringSequenceMember, convertAndCheck(stringSequenceMember = toImplArray<String>(stringSequenceMemberValue, 0, isolate, exceptionState), exceptionState), return false);
         impl.setStringSequenceMember(stringSequenceMember);
     }
 
     v8::Local<v8::Value> testInterface2OrUint8ArrayMemberValue = v8Object->Get(v8String(isolate, "testInterface2OrUint8ArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterface2OrUint8ArrayMemberValue.IsEmpty() || testInterface2OrUint8ArrayMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TestInterface2OrUint8Array testInterface2OrUint8ArrayMember;
-        TONATIVE_VOID_EXCEPTIONSTATE_ARGINTERNAL(V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState), exceptionState);
+        TONATIVE_DECLARE(TestInterface2OrUint8Array, testInterface2OrUint8ArrayMember, V8TestInterface2OrUint8Array::toImpl(isolate, testInterface2OrUint8ArrayMemberValue, testInterface2OrUint8ArrayMember, exceptionState), return false);
         impl.setTestInterface2OrUint8ArrayMember(testInterface2OrUint8ArrayMember);
     }
 
     v8::Local<v8::Value> testInterfaceGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceGarbageCollectedMemberValue.IsEmpty() || testInterfaceGarbageCollectedMemberValue->IsUndefined()) {
         // Do nothing.
@@ -305,7 +302,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedMemberValue);
         if (!testInterfaceGarbageCollectedMember && !testInterfaceGarbageCollectedMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceGarbageCollectedMember is not of type TestInterfaceGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceGarbageCollectedMember(testInterfaceGarbageCollectedMember);
     }
@@ -313,7 +310,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> testInterfaceGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceGarbageCollectedOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceGarbageCollectedOrNullMemberValue->IsUndefined()) {
         // Do nothing.
@@ -323,7 +320,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         TestInterfaceGarbageCollected* testInterfaceGarbageCollectedOrNullMember = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceGarbageCollectedOrNullMemberValue);
         if (!testInterfaceGarbageCollectedOrNullMember && !testInterfaceGarbageCollectedOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceGarbageCollectedOrNullMember is not of type TestInterfaceGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceGarbageCollectedOrNullMember(testInterfaceGarbageCollectedOrNullMember);
     }
@@ -331,7 +328,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> testInterfaceMemberValue = v8Object->Get(v8String(isolate, "testInterfaceMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceMemberValue.IsEmpty() || testInterfaceMemberValue->IsUndefined()) {
         // Do nothing.
@@ -339,7 +336,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         TestInterfaceImplementation* testInterfaceMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceMemberValue);
         if (!testInterfaceMember && !testInterfaceMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceMember is not of type TestInterface.");
-            return;
+            return false;
         }
         impl.setTestInterfaceMember(testInterfaceMember);
     }
@@ -347,7 +344,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> testInterfaceOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceOrNullMemberValue.IsEmpty() || testInterfaceOrNullMemberValue->IsUndefined()) {
         // Do nothing.
@@ -357,7 +354,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         TestInterfaceImplementation* testInterfaceOrNullMember = V8TestInterface::toImplWithTypeCheck(isolate, testInterfaceOrNullMemberValue);
         if (!testInterfaceOrNullMember && !testInterfaceOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceOrNullMember is not of type TestInterface.");
-            return;
+            return false;
         }
         impl.setTestInterfaceOrNullMember(testInterfaceOrNullMember);
     }
@@ -365,7 +362,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceWillBeGarbageCollectedMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedMemberValue->IsUndefined()) {
         // Do nothing.
@@ -373,7 +370,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedMemberValue);
         if (!testInterfaceWillBeGarbageCollectedMember && !testInterfaceWillBeGarbageCollectedMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceWillBeGarbageCollectedMember is not of type TestInterfaceWillBeGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceWillBeGarbageCollectedMember(testInterfaceWillBeGarbageCollectedMember);
     }
@@ -381,7 +378,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> testInterfaceWillBeGarbageCollectedOrNullMemberValue = v8Object->Get(v8String(isolate, "testInterfaceWillBeGarbageCollectedOrNullMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (testInterfaceWillBeGarbageCollectedOrNullMemberValue.IsEmpty() || testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsUndefined()) {
         // Do nothing.
@@ -391,7 +388,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         TestInterfaceWillBeGarbageCollected* testInterfaceWillBeGarbageCollectedOrNullMember = V8TestInterfaceWillBeGarbageCollected::toImplWithTypeCheck(isolate, testInterfaceWillBeGarbageCollectedOrNullMemberValue);
         if (!testInterfaceWillBeGarbageCollectedOrNullMember && !testInterfaceWillBeGarbageCollectedOrNullMemberValue->IsNull()) {
             exceptionState.throwTypeError("member testInterfaceWillBeGarbageCollectedOrNullMember is not of type TestInterfaceWillBeGarbageCollected.");
-            return;
+            return false;
         }
         impl.setTestInterfaceWillBeGarbageCollectedOrNullMember(testInterfaceWillBeGarbageCollectedOrNullMember);
     }
@@ -399,7 +396,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> uint8ArrayMemberValue = v8Object->Get(v8String(isolate, "uint8ArrayMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (uint8ArrayMemberValue.IsEmpty() || uint8ArrayMemberValue->IsUndefined()) {
         // Do nothing.
@@ -407,7 +404,7 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         DOMUint8Array* uint8ArrayMember = uint8ArrayMemberValue->IsUint8Array() ? V8Uint8Array::toImpl(v8::Local<v8::Uint8Array>::Cast(uint8ArrayMemberValue)) : 0;
         if (!uint8ArrayMember && !uint8ArrayMemberValue->IsNull()) {
             exceptionState.throwTypeError("member uint8ArrayMember is not of type Uint8Array.");
-            return;
+            return false;
         }
         impl.setUint8ArrayMember(uint8ArrayMember);
     }
@@ -415,15 +412,16 @@ void V8TestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
     v8::Local<v8::Value> unrestrictedDoubleMemberValue = v8Object->Get(v8String(isolate, "unrestrictedDoubleMember"));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
-        return;
+        return false;
     }
     if (unrestrictedDoubleMemberValue.IsEmpty() || unrestrictedDoubleMemberValue->IsUndefined()) {
         // Do nothing.
     } else {
-        TONATIVE_VOID_EXCEPTIONSTATE(double, unrestrictedDoubleMember, toDouble(unrestrictedDoubleMemberValue, exceptionState), exceptionState);
+        TONATIVE_DECLARE(double, unrestrictedDoubleMember, convertAndCheck(unrestrictedDoubleMember = toDouble(unrestrictedDoubleMemberValue, exceptionState), exceptionState), return false);
         impl.setUnrestrictedDoubleMember(unrestrictedDoubleMember);
     }
 
+    return true;
 }
 
 v8::Local<v8::Value> toV8(const TestDictionary& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)