IDL compiler: Remove AnnotatedType

Bug: 839389
Change-Id: Ib131f7dcc043af790bd91ec586f52c4849591165
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1695748Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
Commit-Queue: Yuki Shiino <yukishiino@chromium.org>
Cr-Commit-Position: refs/heads/master@{#676361}

third_party/blink/renderer/bindings/scripts/web_idl/extended_attribute.py

@@ -162,6 +162,9 @@ class ExtendedAttributes(object):
             for k, v in groupby(attributes, key=lambda x: x.key)
         }
 
+    def __bool__(self):
+        return bool(self._attributes)
+
     def __contains__(self, key):
         """
         Returns True if this has an extended attribute with the |key|.
@@ -178,6 +181,9 @@ class ExtendedAttributes(object):
             for attr in attrs:
                 yield attr
 
+    def __len__(self):
+        return len(list(self.__iter__()))
+
     def __str__(self):
         attrs = [str(attr) for attr in self]
         return '[{}]'.format(', '.join(attrs))
@@ -185,6 +191,9 @@ class ExtendedAttributes(object):
     def make_copy(self):
         return ExtendedAttributes(map(ExtendedAttribute.make_copy, self))
 
+    def keys(self):
+        return self._attributes.keys()
+
     def get(self, key):
         """
         Returns an exnteded attribute whose key is |key|.

third_party/blink/renderer/bindings/scripts/web_idl/idl_types_test.py

@@ -6,7 +6,6 @@ import unittest
 
 from .extended_attribute import ExtendedAttribute
 from .extended_attribute import ExtendedAttributes
-from .idl_types import AnnotatedType
 from .idl_types import FrozenArrayType
 from .idl_types import NullableType
 from .idl_types import PromiseType
@@ -44,10 +43,10 @@ class IdlTypesTest(unittest.TestCase):
         self.assertTrue(FrozenArrayType(short_type).is_frozen_array)
         self.assertTrue(UnionType([short_type, string_type]).is_union)
         self.assertTrue(NullableType(short_type).is_nullable)
-        annotated_type = AnnotatedType(short_type, ext_attrs)
+        self.assertFalse(NullableType(short_type).is_numeric)
+        annotated_type = SimpleType('short', extended_attributes=ext_attrs)
         self.assertTrue(annotated_type.is_annotated)
-        # Predictors are not transparent
-        self.assertFalse(annotated_type.is_numeric)
+        self.assertTrue(annotated_type.is_numeric)
 
         self.assertFalse(SimpleType('long').is_string)
         self.assertFalse(SimpleType('DOMString').is_object)
@@ -85,15 +84,17 @@ class IdlTypesTest(unittest.TestCase):
 
         ext_attrs = ExtendedAttributes(
             [ExtendedAttribute('TreatNullAs', 'EmptyString')])
-        self.assertEqual('StringTreatNullAs',
-                         AnnotatedType(string_type, ext_attrs).type_name)
+        self.assertEqual(
+            'StringTreatNullAs',
+            SimpleType('DOMString', extended_attributes=ext_attrs).type_name)
 
     def test_union_types(self):
         # Test target: ((unrestricted double or object)? or
         #               [TreatNullAs=EmptyString] DOMString)
         treat_null_as = ExtendedAttribute('TreatNullAs', 'EmptyString')
-        annotated_string = AnnotatedType(
-            SimpleType('DOMString'), ExtendedAttributes([treat_null_as]))
+        annotated_string = SimpleType(
+            'DOMString',
+            extended_attributes=ExtendedAttributes([treat_null_as]))
         obj = SimpleType('object')
         unrestricted_double = SimpleType('unrestricted double')
         union = UnionType(

third_party/blink/renderer/bindings/scripts/web_idl/ir_builder.py

@@ -10,7 +10,6 @@ from .dictionary import Dictionary
 from .dictionary import DictionaryMember
 from .enumeration import Enumeration
 from .extended_attribute import ExtendedAttributes
-from .idl_types import AnnotatedType
 from .idl_types import FrozenArrayType
 from .idl_types import NullableType
 from .idl_types import PromiseType
@@ -207,83 +206,76 @@ class _IRBuilder(object):
         return self._create_ref_to_idl_def(node.GetName())
 
     def _build_type(self, node):
-        def build_maybe_inner_type(node):
-            return self._build_type_internal(node.GetChildren()[0])
-
-        def build_maybe_nullable_type(node):
-            maybe_inner_type = build_maybe_inner_type(node)
-            if node.GetProperty('NULLABLE'):
-                return NullableType(maybe_inner_type)
-            return maybe_inner_type
-
-        def build_maybe_annotated_type(node):
-            type_nodes = list(node.GetChildren())
-            extended_attributes = self._take_extended_attributes(type_nodes)
-            assert len(type_nodes) == 1
-            maybe_inner_type = build_maybe_nullable_type(node)
-            if extended_attributes:
-                return AnnotatedType(
-                    inner_type=maybe_inner_type,
-                    extended_attributes=extended_attributes)
-            return maybe_inner_type
-
         assert node.GetClass() == 'Type'
-        return build_maybe_annotated_type(node)
+        if node.GetProperty('NULLABLE'):
+            return NullableType(self._build_type_internal(node.GetChildren()))
+        return self._build_type_internal(node.GetChildren())
 
-    def _build_type_internal(self, node):
+    def _build_type_internal(self, nodes):
         """
         Args:
-            node: The body node of the type definition, which is supposed to be
-                the first child of a 'Type' node.
+            nodes: The child nodes of a 'Type' node.
         """
 
-        def build_frozen_array_type(node):
+        def build_frozen_array_type(node, extended_attributes):
             assert len(node.GetChildren()) == 1
             return FrozenArrayType(
                 element_type=self._build_type(node.GetChildren()[0]),
+                extended_attributes=extended_attributes,
                 debug_info=self._build_debug_info(node))
 
-        def build_promise_type(node):
+        def build_promise_type(node, extended_attributes):
             assert len(node.GetChildren()) == 1
             return PromiseType(
                 result_type=self._build_type(node.GetChildren()[0]),
+                extended_attributes=extended_attributes,
                 debug_info=self._build_debug_info(node))
 
-        def build_union_type(node):
-            union_type = UnionType(
-                member_types=map(self._build_type, node.GetChildren()))
-            return union_type
+        def build_union_type(node, extended_attributes):
+            return UnionType(
+                member_types=map(self._build_type, node.GetChildren()),
+                extended_attributes=extended_attributes,
+                debug_info=self._build_debug_info(node))
 
-        def build_record_type(node):
+        def build_record_type(node, extended_attributes):
             key_node, value_node = node.GetChildren()
             return RecordType(
                 # idl_parser doesn't produce a 'Type' node for the key type,
                 # hence we need to skip one level.
-                key_type=self._build_type_internal(key_node),
+                key_type=self._build_type_internal([key_node]),
                 value_type=self._build_type(value_node),
+                extended_attributes=extended_attributes,
                 debug_info=self._build_debug_info(node))
 
-        def build_reference_type(node):
+        def build_reference_type(node, extended_attributes):
             identifier = node.GetName()
-            ref_type = ReferenceType(
+            return ReferenceType(
                 ref_to_idl_type=self._create_ref_to_idl_type(identifier),
+                extended_attributes=extended_attributes,
                 debug_info=self._build_debug_info(node))
-            return ref_type
 
-        def build_sequence_type(node):
+        def build_sequence_type(node, extended_attributes):
             return SequenceType(
                 element_type=self._build_type(node.GetChildren()[0]),
+                extended_attributes=extended_attributes,
                 debug_info=self._build_debug_info(node))
 
-        def build_simple_type(node):
-            type_name = node.GetName()
-            if type_name is None:
+        def build_simple_type(node, extended_attributes):
+            name = node.GetName()
+            if name is None:
                 assert node.GetClass() == 'Any'
-                type_name = node.GetClass().lower()
+                name = node.GetClass().lower()
             if node.GetProperty('UNRESTRICTED'):
-                type_name = 'unrestricted ' + type_name
+                name = 'unrestricted {}'.format(name)
             return SimpleType(
-                name=type_name, debug_info=self._build_debug_info(node))
+                name=name,
+                extended_attributes=extended_attributes,
+                debug_info=self._build_debug_info(node))
+
+        type_nodes = list(nodes)
+        extended_attributes = self._take_extended_attributes(type_nodes)
+        assert len(type_nodes) == 1
+        body_node = type_nodes[0]
 
         build_functions = {
             'Any': build_simple_type,
@@ -296,7 +288,8 @@ class _IRBuilder(object):
             'Typeref': build_reference_type,
             'UnionType': build_union_type,
         }
-        return build_functions[node.GetClass()](node)
+        return build_functions[body_node.GetClass()](body_node,
+                                                     extended_attributes)
 
     def _take_and_build(self, node_class, build_func, node_list):
         """