IDL union: nullable support

Source/bindings/scripts/v8_union.py

 # 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.
 
 import v8_utilities
 
 
 UNION_H_INCLUDES = frozenset([
     'bindings/core/v8/ExceptionState.h',
     'bindings/core/v8/V8Binding.h',
     'platform/heap/Handle.h',
 ])
 
 cpp_includes = set()
 header_forward_decls = set()
 
 
 def union_context(union_types, interfaces_info):
+    # For container classes we strip nullable wrappers. For example,
+    # both (A or B)? and (A? or B) will become AOrB. This should be OK
+    # because container classes can handle null and it seems that
+    # distinguishing (A or B)? and (A? or B) doesn't make sense.
+    container_cpp_types = set()
+    union_types_for_containers = set()
+    nullable_cpp_types = set()
+    for union_type in union_types:
+        cpp_type = union_type.cpp_type
+        if cpp_type not in container_cpp_types:
+            union_types_for_containers.add(union_type.as_union_type)

[haraken, 2014/11/07 18:06:31]

I'm not sure what .as_union_type is for. Can we just use union_type ?

[Jens Widell, 2014/11/07 18:15:46]

Since container_context() uses union_type.name, it makes a difference. But it
only affects (Python) exception messages, so the difference is insignificant.

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

Yes, it only affects exception messages, but just using union_type would be
suitable. Done.

+            container_cpp_types.add(cpp_type)
+        if union_type.includes_nullable_type:

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

Should this also check union_type.is_nullable?

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

IdlNullableType.includes_nullable_type is True so it should already be covered.

+            nullable_cpp_types.add(cpp_type)
+
+    union_types_for_containers = sorted(union_types_for_containers,
+                                        key=lambda union_type: union_type.name)

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

It doesn't really matter (stable order in the generated code is the priority)
but with (A? or B) and (A or C) you'll get the order AOrC, AorB in the generated
code, won't you?

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

Good catch! Then, we should use idl_type.cpp_type as the sort key. Done.

+    nullable_cpp_types = sorted(nullable_cpp_types)
+
     return {
         'containers': [container_context(union_type, interfaces_info)
-                       for union_type in union_types],
+                       for union_type in union_types_for_containers],
         'cpp_includes': sorted(cpp_includes),
         'header_forward_decls': sorted(header_forward_decls),
         'header_includes': sorted(UNION_H_INCLUDES),
+        'nullable_cpp_types': nullable_cpp_types,
     }
 
 
 def container_context(union_type, interfaces_info):
     members = []
 
     # These variables refer to member contexts if the given union type has
     # corresponding types. They are used for V8 -> impl conversion.
     array_buffer_type = None
     array_buffer_view_type = None
@@ skipping 27 matching lines @@
             if numeric_type:
                 raise Exception('%s is ambiguous.' % union_type.name)
             numeric_type = context
         elif member.is_string_type:
             if string_type:
                 raise Exception('%s is ambiguous.' % union_type.name)
             string_type = context
         else:
             raise Exception('%s is not supported as an union member.' % member.name)
 
+    # Nullable restriction checks
+    nullable_members = union_type.number_of_nullable_member_types
+    if nullable_members > 1:
+        raise Exception('%s contains more than one nullable members' % union_type.name)
+    if dictionary_type and nullable_members == 1:
+        raise Exception('%s has a dictionary and a nullable member' % union_type.name)
+
     return {
         'array_buffer_type': array_buffer_type,
         'array_buffer_view_type': array_buffer_view_type,
         'boolean_type': boolean_type,
-        'cpp_class': union_type.name,
+        'cpp_class': union_type.cpp_type,
         'dictionary_type': dictionary_type,
+        'includes_nullable_type': union_type.includes_nullable_type,

[haraken, 2014/11/07 18:06:31]

includes_nullable_type => contains_nullable_type ?

Or simply, is_nullable ?

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

"includes a nullable type" is what the spec is using so I'd prefer not changing
the name.
http://heycam.github.io/webidl/#dfn-includes-a-nullable-type

         'interface_types': interface_types,
         'members': members,
         'needs_trace': any(member['is_traceable'] for member in members),
         'numeric_type': numeric_type,
         'string_type': string_type,
     }
 
 
 def member_context(member, interfaces_info):
     cpp_includes.update(member.includes_for_type)
     interface_info = interfaces_info.get(member.name, None)
     if interface_info:
         cpp_includes.update(interface_info.get('dependencies_include_paths', []))
         header_forward_decls.add(member.implemented_as)
+    if member.is_nullable:
+        member = member.inner_type
     return {
         'cpp_name': v8_utilities.uncapitalize(member.name),
         'cpp_type': member.cpp_type_args(used_in_cpp_sequence=True),
         'cpp_local_type': member.cpp_type,
         'cpp_value_to_v8_value': member.cpp_value_to_v8_value(
             cpp_value='impl.getAs%s()' % member.name, isolate='isolate',
             creation_context='creationContext'),
         'is_traceable': member.is_traceable,
         'rvalue_cpp_type': member.cpp_type_args(used_as_rvalue_type=True),
         'specific_type_enum': 'SpecificType' + member.name,
         'type_name': member.name,
         'v8_value_to_local_cpp_value': member.v8_value_to_local_cpp_value(
             {}, 'v8Value', 'cppValue', needs_exception_state_for_string=True),
     }