1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
# Copyright 2023 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from .composition_parts import Identifier
from .composition_parts import WithCodeGeneratorInfo
from .composition_parts import WithComponent
from .composition_parts import WithDebugInfo
from .composition_parts import WithExposure
from .composition_parts import WithExtendedAttributes
from .idl_type import IdlType
from .ir_map import IRMap
from .make_copy import make_copy
from .operation import Operation
from .operation import OperationGroup
from .reference import RefById
from .user_defined_type import UserDefinedType
class AsyncIterator(UserDefinedType, WithExtendedAttributes,
WithCodeGeneratorInfo, WithExposure, WithComponent,
WithDebugInfo):
"""
Represents an async iterator type for 'asynchronous default iterator
objects' [1], which exists for every interface that has a 'async iterator'
[2].
[1] https://webidl.spec.whatwg.org/#es-default-asynchronous-iterator-object
[2] https://webidl.spec.whatwg.org/#es-asynchronous-iterable
"""
@staticmethod
def identifier_for(interface_identifier):
"""
Returns the identifier of the asynchronous iterator type of the given
interface type.
"""
assert isinstance(interface_identifier, Identifier)
return Identifier('AsyncIterator_{}'.format(interface_identifier))
class IR(IRMap.IR, WithExtendedAttributes, WithCodeGeneratorInfo,
WithExposure, WithComponent, WithDebugInfo):
def __init__(self,
interface,
component,
key_type=None,
value_type=None,
operations=None):
assert isinstance(interface, RefById)
assert key_type is None or isinstance(key_type, IdlType)
assert isinstance(value_type, IdlType)
assert isinstance(operations, (list, tuple))
assert all(
isinstance(operation, Operation.IR)
for operation in operations)
identifier = AsyncIterator.identifier_for(interface.identifier)
IRMap.IR.__init__(self, identifier, IRMap.IR.Kind.ASYNC_ITERATOR)
WithExtendedAttributes.__init__(self)
WithCodeGeneratorInfo.__init__(self)
WithExposure.__init__(self)
WithComponent.__init__(self, component)
WithDebugInfo.__init__(self)
self.interface = interface
self.key_type = key_type
self.value_type = value_type
self.constructors = []
self.constructor_groups = []
self.legacy_factory_functions = []
self.legacy_factory_function_groups = []
self.operations = list(operations)
self.operation_groups = []
self.inherited = None
self.direct_subclasses = []
self.subclasses = []
self.tag = None
self.max_subclass_tag = None
def iter_all_members(self):
return list(self.operations)
def iter_all_overload_groups(self):
return list(self.operation_groups)
def __init__(self, ir):
assert isinstance(ir, AsyncIterator.IR)
ir = make_copy(ir)
UserDefinedType.__init__(self, ir.identifier)
WithExtendedAttributes.__init__(self, ir, readonly=True)
WithCodeGeneratorInfo.__init__(self, ir, readonly=True)
WithExposure.__init__(self, ir, readonly=True)
WithComponent.__init__(self, ir, readonly=True)
WithDebugInfo.__init__(self, ir)
self._interface = ir.interface
self._key_type = ir.key_type
self._value_type = ir.value_type
self._operations = tuple([
Operation(operation_ir, owner=self)
for operation_ir in ir.operations
])
self._operation_groups = tuple([
OperationGroup(
group_ir,
list(
filter(lambda x: x.identifier == group_ir.identifier,
self._operations)),
owner=self) for group_ir in ir.operation_groups
])
self._tag = ir.tag
self._max_subclass_tag = ir.max_subclass_tag
@property
def interface(self):
"""Returns the interface that defines this async iterator."""
return self._interface
@property
def key_type(self):
"""Returns the key type or None."""
return self._key_type
@property
def value_type(self):
"""Returns the value type."""
return self._value_type
@property
def inherited(self):
# Just to be compatible with web_idl.Interface.
return None
@property
def subclasses(self):
# Just to be compatible with web_idl.Interface.
return ()
@property
def attributes(self):
"""Returns attributes."""
return ()
@property
def constants(self):
"""Returns constants."""
return ()
@property
def constructors(self):
"""Returns constructors."""
return ()
@property
def constructor_groups(self):
"""Returns groups of constructors."""
return ()
@property
def legacy_factory_functions(self):
"""Returns legacy factory functions."""
return ()
@property
def legacy_factory_function_groups(self):
"""Returns groups of overloaded legacy factory functions."""
return ()
@property
def operations(self):
"""Returns operations."""
return self._operations
@property
def operation_groups(self):
"""Returns a list of OperationGroups."""
return self._operation_groups
@property
def exposed_constructs(self):
"""Returns exposed constructs."""
return ()
@property
def tag(self):
"""Returns a tag integer or None."""
return self._tag
@property
def max_subclass_tag(self):
"""Returns a tag integer or None."""
return self._max_subclass_tag
# UserDefinedType overrides
@property
def is_async_iterator(self):
return True
|
