IDL compiler: interface and integer types for special operations

Source/bindings/scripts/unstable/v8_interface.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 21 matching lines @@
 This is a rewrite of the Perl IDL compiler in Python, but is not complete.
 Once it is complete, we will switch all IDL files over to Python at once.
 Until then, please work on the Perl IDL compiler.
 For details, see bug http://crbug.com/239771
 """
 
 import v8_attributes
 from v8_globals import includes
 import v8_methods
 import v8_types
-from v8_types import inherits_interface
+from v8_types import inherits_interface, is_interface_type
 import v8_utilities
 from v8_utilities import capitalize, conditional_string, cpp_name, has_extended_attribute_value, runtime_enabled_function_name
 
 
 INTERFACE_H_INCLUDES = set([
     'bindings/v8/V8Binding.h',
     'bindings/v8/V8DOMWrapper.h',
     'bindings/v8/WrapperTypeInfo.h',
 ])
 INTERFACE_CPP_INCLUDES = set([
@@ skipping 322 matching lines @@
     if v8_types.array_or_sequence_type(idl_type):
         return '%s->IsArray()' % cpp_value
     if v8_types.is_callback_interface(idl_type):
         return ' || '.join(['%s->IsNull()' % cpp_value,
                             '%s->IsFunction()' % cpp_value])
     if v8_types.is_wrapper_type(idl_type):
         type_check = 'V8{idl_type}::hasInstance({cpp_value}, info.GetIsolate())'.format(idl_type=idl_type, cpp_value=cpp_value)
         if argument['is_nullable']:
             type_check = ' || '.join(['%s->IsNull()' % cpp_value, type_check])
         return type_check
-    if v8_types.is_interface_type(idl_type):
+    if is_interface_type(idl_type):
         # Non-wrapper types are just objects: we don't distinguish type
         type_check = '%s->IsObject()' % cpp_value
         if argument['is_nullable']:
             type_check = ' || '.join(['%s->IsNull()' % cpp_value, type_check])
         return type_check
     return None
 
 
 ################################################################################
 # Constructors
@@ skipping 88 matching lines @@
 
 ################################################################################
 # Special operations (methods)
 # http://heycam.github.io/webidl/#idl-special-operations
 ################################################################################
 
 def property_getter(getter):
     def is_null_expression(idl_type):
         if idl_type == 'DOMString':
             return 'element.isNull()'
-        return None
+        if is_interface_type(idl_type):
+            return '!element'
+        return ''
 
     idl_type = getter.idl_type
     extended_attributes = getter.extended_attributes
+    element = 'element.release()' if is_interface_type(idl_type) else 'element'
+
     return {
         'cpp_type': v8_types.cpp_type(idl_type),
         'is_custom':
             'Custom' in extended_attributes and
             (not extended_attributes['Custom'] or
              has_extended_attribute_value(getter, 'Custom', 'PropertyGetter')),
         'is_custom_property_enumerator': has_extended_attribute_value(
             getter, 'Custom', 'PropertyEnumerator'),
         'is_custom_property_query': has_extended_attribute_value(
             getter, 'Custom', 'PropertyQuery'),
         'is_enumerable': 'NotEnumerable' not in extended_attributes,
         'is_null_expression': is_null_expression(idl_type),
         'is_raises_exception': 'RaisesException' in extended_attributes,
         'name': cpp_name(getter),
-        'v8_set_return_value': v8_types.v8_set_return_value(idl_type, 'element', extended_attributes=extended_attributes, script_wrappable='collection'),
+        'v8_set_return_value': v8_types.v8_set_return_value(idl_type, element, extended_attributes=extended_attributes, script_wrappable='collection'),
     }
 
 
 def property_setter(setter):
     idl_type = setter.arguments[1].idl_type
     extended_attributes = setter.extended_attributes
+    is_raises_exception = 'RaisesException' in extended_attributes
     return {
         'is_custom': 'Custom' in extended_attributes,
-        'is_raises_exception': 'RaisesException' in extended_attributes,
+        'has_exception_state': is_raises_exception or
+                               v8_types.is_integer_type(idl_type),

[haraken, 2014/01/30 10:55:25]

Let me confirm: Did we decide that we should implicitly throw exceptions when we
have integers, even if we don't have [RaisesException] IDL attributes?

[Nils Barth (inactive), 2014/01/30 11:00:50]

Yes, we raise exceptions for integer setters (for attributes),
since they may be invalid: this matches existing attribute setter behavior.
We raise exceptions on setters for:
* [RaisesException]
* [StrictTypeChecking]
* integer type

[RaisesException] actually means "pass exceptionState to
Blink function call and then check after call",
but exceptions occur for other reasons.

+        'is_raises_exception': is_raises_exception,
         'name': cpp_name(setter),
         'v8_value_to_local_cpp_value': v8_types.v8_value_to_local_cpp_value(
             idl_type, extended_attributes, 'jsValue', 'propertyValue'),
     }
 
 
 def property_deleter(deleter):
     idl_type = deleter.idl_type
     if idl_type != 'boolean':
         raise Exception(
@@ skipping 104 matching lines @@
         deleter = next(
             method
             for method in interface.operations
             if ('deleter' in method.specials and
                 len(method.arguments) == 1 and
                 method.arguments[0].idl_type == 'DOMString'))
     except StopIteration:
         return None
 
     return property_deleter(deleter)