IDL union: nullable support

Source/bindings/scripts/v8_types.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 175 matching lines @@
     if idl_type.is_interface_type:
         implemented_as_class = idl_type.implemented_as
         if raw_type:
             return implemented_as_class + '*'
         new_type = 'Member' if used_in_cpp_sequence else 'RawPtr'
         ptr_type = cpp_ptr_type(('PassRefPtr' if used_as_rvalue_type else 'RefPtr'), new_type, idl_type.gc_type)
         return cpp_template_type(ptr_type, implemented_as_class)
     if idl_type.is_dictionary:
         return base_idl_type
     if idl_type.is_union_type:
-        return idl_type.name
+        return idl_type.as_union_type.name

[Jens Widell, 2014/11/07 07:11:53]

So, if you have (A? or B), the name generated here will be "AOrNullOrB", and
then we'll have V8AOrNullOrB::toImpl() which doesn't handle null and
V8AOrNullOrBOrNull::toImpl() which does. :-)

This type name generation is per WebIDL, but for the purpose of generating C++
classes internally it would make sense to strip nullability from the members and
treat it separately (as the rest of this CL does.)

[bashi, 2014/11/07 10:07:53]

You are right. The cpp_type is not necessary the same as Web IDL's type name,
and I think we can treat (A? or B) and (A or B)? in the same way (I can't think
of a situation that we want to distinguish them). Done.

For record, it seems that (A? or B)? is allowed (I'm not 100% sure), but I also
think we can handle this the same way(generate AOrB and V8AOrBOrNull::toImpl).

[Jens Widell, 2014/11/07 10:58:19]

The types (A? or B) and (A or B)? should be handled the same in all ways,
AFAICT.
It's probably allowed, but should also be handled the same way. One could
imagine that happening (by mistake) in a spec if the union is a typedef:

  typedef (A? or B) Thing;

and then

  void f(Thing? x);

[bashi, 2014/11/08 07:10:34]

Thanks for the confirmation:)

 
     # Default, assume native type is a pointer with same type name as idl type
     return base_idl_type + '*'
 
 
 def cpp_type_initializer(idl_type):
     """Returns a string containing a C++ initialization statement for the
     corresponding type.
 
     |idl_type| argument is of type IdlType.
@@ skipping 303 matching lines @@
         return ''
 
     # Array or sequence types
     native_array_element_type = idl_type.native_array_element_type
     if native_array_element_type:
         return v8_value_to_cpp_value_array_or_sequence(native_array_element_type, v8_value, index)
 
     # Simple types
     idl_type = idl_type.preprocessed_type
     add_includes_for_type(idl_type)
-    base_idl_type = idl_type.name if idl_type.is_union_type else idl_type.base_type
+    base_idl_type = idl_type.as_union_type.name if idl_type.is_union_type else idl_type.base_type
 
     if 'EnforceRange' in extended_attributes:
         arguments = ', '.join([v8_value, 'EnforceRange', 'exceptionState'])
     elif 'Clamp' in extended_attributes:
         arguments = ', '.join([v8_value, 'Clamp', 'exceptionState'])
     elif idl_type.v8_conversion_needs_exception_state:
         arguments = ', '.join([v8_value, 'exceptionState'])
     else:
         arguments = v8_value
 
     if base_idl_type in V8_VALUE_TO_CPP_VALUE:
         cpp_expression_format = V8_VALUE_TO_CPP_VALUE[base_idl_type]
     elif idl_type.is_array_buffer_or_view:
         cpp_expression_format = (
             '{v8_value}->Is{idl_type}() ? '
             'V8{idl_type}::toImpl(v8::Handle<v8::{idl_type}>::Cast({v8_value})) : 0')
-    elif idl_type.is_dictionary or idl_type.is_union_type:
+    elif idl_type.use_output_parameter_for_result:
+        if idl_type.includes_nullable_type:
+            base_idl_type += 'OrNull'
         cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, {variable_name}, exceptionState)'
     elif needs_type_check:
         cpp_expression_format = (
             'V8{idl_type}::toImplWithTypeCheck({isolate}, {v8_value})')
     else:
         cpp_expression_format = (
             'V8{idl_type}::toImpl(v8::Handle<v8::Object>::Cast({v8_value}))')
 
     return cpp_expression_format.format(arguments=arguments, idl_type=base_idl_type, v8_value=v8_value, variable_name=variable_name, isolate=isolate)
 
@@ skipping 305 matching lines @@
 # Utility properties for nullable types
 ################################################################################
 
 
 def cpp_type_has_null_value(idl_type):
     # - String types (String/AtomicString) represent null as a null string,
     #   i.e. one for which String::isNull() returns true.
     # - Enum types, as they are implemented as Strings.
     # - Wrapper types (raw pointer or RefPtr/PassRefPtr) represent null as
     #   a null pointer.
+    # - Union types, as thier container classes can represent null value.
     # - 'Object' type. We use ScriptValue for object type.
     return (idl_type.is_string_type or idl_type.is_wrapper_type or
-            idl_type.is_enum or idl_type.base_type == 'object')
+            idl_type.is_enum or idl_type.is_union_type
+            or idl_type.base_type == 'object')
 
 IdlTypeBase.cpp_type_has_null_value = property(cpp_type_has_null_value)
 
 
 def is_implicit_nullable(idl_type):
     # Nullable type where the corresponding C++ type supports a null value.
     return idl_type.is_nullable and idl_type.cpp_type_has_null_value
 
 
 def is_explicit_nullable(idl_type):
     # Nullable type that isn't implicit nullable (see above.) For such types,
     # we use Nullable<T> or similar explicit ways to represent a null value.
     return idl_type.is_nullable and not idl_type.is_implicit_nullable
 
 IdlTypeBase.is_implicit_nullable = property(is_implicit_nullable)
 IdlUnionType.is_implicit_nullable = False
 IdlTypeBase.is_explicit_nullable = property(is_explicit_nullable)
+
+
+def number_of_nullable_member_types_union(idl_type):
+    # http://heycam.github.io/webidl/#dfn-number-of-nullable-member-types
+    count = 0
+    for member in idl_type.member_types:
+        if member.is_nullable:
+            count += 1
+            member = member.inner_type
+        if member.is_union_type:
+            count += number_of_nullable_member_types_union(member)
+    return count
+
+IdlUnionType.number_of_nullable_member_types = property(
+    number_of_nullable_member_types_union)
+
+
+def includes_nullable_type_union(idl_type):
+    # http://heycam.github.io/webidl/#dfn-includes-a-nullable-type
+    return idl_type.number_of_nullable_member_types == 1
+
+IdlTypeBase.includes_nullable_type = False
+IdlNullableType.includes_nullable_type = True
+IdlUnionType.includes_nullable_type = property(includes_nullable_type_union)