# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from .argument import Argument
from .ast_group import AstGroup
from .async_iterator import AsyncIterator
from .attribute import Attribute
from .callback_function import CallbackFunction
from .callback_interface import CallbackInterface
from .composition_parts import Component
from .composition_parts import DebugInfo
from .composition_parts import Identifier
from .composition_parts import Location
from .constant import Constant
from .constructor import Constructor
from .dictionary import Dictionary
from .dictionary import DictionaryMember
from .enumeration import Enumeration
from .extended_attribute import ExtendedAttribute
from .extended_attribute import ExtendedAttributes
from .idl_type import IdlTypeFactory
from .includes import Includes
from .interface import AsyncIterable
from .interface import Interface
from .interface import Iterable
from .interface import Maplike
from .interface import Setlike
from .literal_constant import LiteralConstant
from .make_copy import make_copy
from .namespace import Namespace
from .operation import Operation
from .sync_iterator import SyncIterator
from .typedef import Typedef
def load_and_register_idl_definitions(filepaths, register_ir,
create_ref_to_idl_def, idl_type_factory):
"""
Reads ASTs from |filepaths| and builds IRs from ASTs.
Args:
filepaths: Paths to pickle files that store AST nodes.
register_ir: A callback function that registers the argument as an
IR.
create_ref_to_idl_def: A callback function that creates a reference
to an IDL definition from the given identifier.
idl_type_factory: All IdlType instances will be created through this
factory.
"""
assert callable(register_ir)
for filepath in filepaths:
asts = AstGroup.read_from_file(filepath)
builder = _IRBuilder(
component=Component(asts.component),
for_testing=asts.for_testing,
create_ref_to_idl_def=create_ref_to_idl_def,
idl_type_factory=idl_type_factory)
for file_node in asts:
assert file_node.GetClass() == 'File'
for top_level_node in file_node.GetChildren():
register_ir(builder.build_top_level_def(top_level_node))
class _IRBuilder(object):
def __init__(self, component, for_testing, create_ref_to_idl_def,
idl_type_factory):
"""
Args:
component: A Component to which the built IRs are associated.
for_testing: True if the IDL definitions are meant for testing
purpose only.
create_ref_to_idl_def: A callback function that creates a reference
to an IDL definition from the given identifier.
idl_type_factory: All IdlType instances will be created through this
factory.
"""
assert isinstance(component, Component)
assert isinstance(for_testing, bool)
assert callable(create_ref_to_idl_def)
assert isinstance(idl_type_factory, IdlTypeFactory)
self._component = component
self._for_testing = for_testing
self._create_ref_to_idl_def = create_ref_to_idl_def
self._idl_type_factory = idl_type_factory
def build_top_level_def(self, node):
build_functions = {
'Callback': self._build_callback_function,
'Dictionary': self._build_dictionary,
'Enum': self._build_enumeration,
'Includes': self._build_includes,
'Interface': self._build_interface,
'Namespace': self._build_namespace,
'Typedef': self._build_typedef,
}
ir = build_functions[node.GetClass()](node)
ir.code_generator_info.set_for_testing(self._for_testing)
return ir
# Builder functions for top-level definitions
def _build_interface(self, node):
if node.GetProperty('CALLBACK'):
return self._build_callback_interface(node)
identifier = Identifier(node.GetName())
child_nodes = list(node.GetChildren())
inherited = self._take_inheritance(child_nodes)
stringifier_members = self._take_stringifier(child_nodes)
async_iterable = self._take_async_iterable(
child_nodes, interface_identifier=identifier)
iterable = self._take_iterable(child_nodes,
interface_identifier=identifier)
maplike = self._take_maplike(
child_nodes, interface_identifier=identifier)
setlike = self._take_setlike(
child_nodes, interface_identifier=identifier)
extended_attributes = self._take_extended_attributes(child_nodes)
members = [
self._build_interface_member(
child, interface_identifier=identifier)
for child in child_nodes
]
if stringifier_members:
members.extend(filter(None, stringifier_members))
attributes = []
constants = []
constructors = []
operations = []
for member in members:
if isinstance(member, Attribute.IR):
attributes.append(member)
elif isinstance(member, Constant.IR):
constants.append(member)
elif isinstance(member, Constructor.IR):
constructors.append(member)
elif isinstance(member, Operation.IR):
operations.append(member)
else:
assert False
legacy_factory_functions = self._build_legacy_factory_function(node)
return Interface.IR(identifier=identifier,
is_partial=bool(node.GetProperty('PARTIAL')),
is_mixin=bool(node.GetProperty('MIXIN')),
inherited=inherited,
attributes=attributes,
constants=constants,
constructors=constructors,
legacy_factory_functions=legacy_factory_functions,
operations=operations,
async_iterable=async_iterable,
iterable=iterable,
maplike=maplike,
setlike=setlike,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_namespace(self, node):
child_nodes = list(node.GetChildren())
extended_attributes = self._take_extended_attributes(child_nodes)
members = list(map(self._build_interface_member, child_nodes))
attributes = []
constants = []
operations = []
for member in members:
if isinstance(member, Attribute.IR):
member.is_static = True
attributes.append(member)
elif isinstance(member, Constant.IR):
constants.append(member)
elif isinstance(member, Operation.IR):
member.is_static = True
operations.append(member)
else:
assert False
return Namespace.IR(
identifier=Identifier(node.GetName()),
is_partial=bool(node.GetProperty('PARTIAL')),
attributes=attributes,
constants=constants,
operations=operations,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_interface_member(self,
node,
fallback_extended_attributes=None,
interface_identifier=None):
def build_attribute(node):
child_nodes = list(node.GetChildren())
idl_type = self._take_type(child_nodes)
extended_attributes = self._take_extended_attributes(
child_nodes) or fallback_extended_attributes
assert not child_nodes
return Attribute.IR(
identifier=Identifier(node.GetName()),
idl_type=idl_type,
is_static=bool(node.GetProperty('STATIC')),
is_readonly=bool(node.GetProperty('READONLY')),
does_inherit_getter=bool(node.GetProperty('INHERIT')),
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def build_constant(node):
child_nodes = list(node.GetChildren())
value = self._take_constant_value(child_nodes)
extended_attributes = self._take_extended_attributes(
child_nodes) or fallback_extended_attributes
assert len(child_nodes) == 1, child_nodes[0].GetClass()
# idl_parser doesn't produce a 'Type' node for the type of a
# constant, hence we need to skip one level.
idl_type = self._build_type_internal(child_nodes)
return Constant.IR(
identifier=Identifier(node.GetName()),
idl_type=idl_type,
value=value,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def build_constructor(node):
assert isinstance(interface_identifier, Identifier)
child_nodes = list(node.GetChildren())
arguments = self._take_arguments(child_nodes)
extended_attributes = self._take_extended_attributes(
child_nodes) or fallback_extended_attributes
assert not child_nodes
return_type = self._idl_type_factory.reference_type(
interface_identifier)
return Constructor.IR(
identifier=None,
arguments=arguments,
return_type=return_type,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def build_operation(node):
child_nodes = list(node.GetChildren())
arguments = self._take_arguments(child_nodes)
return_type = self._take_type(child_nodes)
extended_attributes = self._take_extended_attributes(
child_nodes) or fallback_extended_attributes
assert not child_nodes
return Operation.IR(
identifier=Identifier(node.GetName()),
arguments=arguments,
return_type=return_type,
is_static=bool(node.GetProperty('STATIC')),
is_getter=bool(node.GetProperty('GETTER')),
is_setter=bool(node.GetProperty('SETTER')),
is_deleter=bool(node.GetProperty('DELETER')),
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
build_functions = {
'Attribute': build_attribute,
'Const': build_constant,
'Constructor': build_constructor,
'Operation': build_operation,
}
return build_functions[node.GetClass()](node)
def _build_legacy_factory_function(self, node):
assert node.GetClass() == 'Interface'
legacy_factory_functions = []
for child in node.GetChildren():
if child.GetClass() == 'ExtAttributes':
interface_ext_attrs = child.GetChildren()
break
else:
return legacy_factory_functions
for ext_attr in interface_ext_attrs:
if ext_attr.GetName() != 'LegacyFactoryFunction':
continue
call_node = ext_attr.GetChildren()[0]
assert call_node.GetClass() == 'Call'
child_nodes = list(call_node.GetChildren())
arguments = self._take_arguments(child_nodes)
return_type = self._idl_type_factory.reference_type(
Identifier(node.GetName()))
assert not child_nodes
legacy_factory_functions.append(
Constructor.IR(identifier=Identifier(call_node.GetName()),
arguments=arguments,
return_type=return_type,
component=self._component,
debug_info=self._build_debug_info(node)))
return legacy_factory_functions
def _build_dictionary(self, node):
child_nodes = list(node.GetChildren())
inherited = self._take_inheritance(child_nodes)
extended_attributes = self._take_extended_attributes(child_nodes)
own_members = list(map(self._build_dictionary_member, child_nodes))
return Dictionary.IR(
identifier=Identifier(node.GetName()),
is_partial=bool(node.GetProperty('PARTIAL')),
inherited=inherited,
own_members=own_members,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_dictionary_member(self, node):
assert node.GetClass() == 'Key'
child_nodes = list(node.GetChildren())
is_required = bool(node.GetProperty('REQUIRED'))
idl_type = self._take_type(child_nodes, is_optional=(not is_required))
default_value = self._take_default_value(child_nodes)
extended_attributes = self._take_extended_attributes(child_nodes)
assert not child_nodes
return DictionaryMember.IR(
identifier=Identifier(node.GetName()),
idl_type=idl_type,
default_value=default_value,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_callback_interface(self, node):
assert node.GetProperty('CALLBACK')
child_nodes = list(node.GetChildren())
extended_attributes = self._take_extended_attributes(child_nodes)
members = list(map(self._build_interface_member, child_nodes))
constants = []
operations = []
for member in members:
if isinstance(member, Constant.IR):
constants.append(member)
elif isinstance(member, Operation.IR):
operations.append(member)
else:
assert False
return CallbackInterface.IR(
identifier=Identifier(node.GetName()),
constants=constants,
operations=operations,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_callback_function(self, node):
child_nodes = list(node.GetChildren())
arguments = self._take_arguments(child_nodes)
return_type = self._take_type(child_nodes)
extended_attributes = self._take_extended_attributes(child_nodes)
assert not child_nodes
return CallbackFunction.IR(
identifier=Identifier(node.GetName()),
arguments=arguments,
return_type=return_type,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_enumeration(self, node):
child_nodes = list(node.GetChildren())
extended_attributes = self._take_extended_attributes(child_nodes)
assert all(child.GetClass() == 'EnumItem' for child in child_nodes)
values = [child.GetName() for child in child_nodes]
return Enumeration.IR(
identifier=Identifier(node.GetName()),
values=values,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_typedef(self, node):
child_nodes = list(node.GetChildren())
idl_type = self._take_type(child_nodes)
assert not child_nodes
return Typedef.IR(
identifier=Identifier(node.GetName()),
idl_type=idl_type,
component=self._component,
debug_info=self._build_debug_info(node))
def _build_includes(self, node):
return Includes.IR(
interface_identifier=Identifier(node.GetName()),
mixin_identifier=Identifier(node.GetProperty('REFERENCE')),
component=self._component,
debug_info=self._build_debug_info(node))
# Helper functions sorted alphabetically
def _build_arguments(self, node):
def build_argument(node, index):
assert node.GetClass() == 'Argument'
child_nodes = list(node.GetChildren())
is_optional = bool(node.GetProperty('OPTIONAL'))
is_variadic = bool(self._take_is_variadic_argument(child_nodes))
# The parser may place extended attributes on arguments, but they
# should be applied to types.
extended_attributes = self._take_extended_attributes(child_nodes)
idl_type = self._take_type(
child_nodes,
is_optional=is_optional,
is_variadic=is_variadic,
extended_attributes=extended_attributes)
default_value = self._take_default_value(child_nodes)
assert not child_nodes
return Argument.IR(
identifier=Identifier(node.GetName()),
index=index,
idl_type=idl_type,
default_value=default_value)
assert node.GetClass() == 'Arguments'
return [
build_argument(node, i)
for i, node in enumerate(node.GetChildren())
]
def _build_async_iterable(self, node, interface_identifier):
assert node.GetClass() == 'AsyncIterable'
assert isinstance(interface_identifier, Identifier)
child_nodes = list(node.GetChildren())
arguments = self._take_arguments(child_nodes)
extended_attributes = self._take_extended_attributes(child_nodes)
types = list(map(self._build_type, child_nodes))
assert len(types) == 1 or len(types) == 2
iter_ops = self._create_async_iterable_operations(
node, interface_identifier, arguments, extended_attributes)
if len(types) == 1: # value iterator
key_type, value_type = (None, types[0])
iter_ops[Identifier('values')].is_async_iterator = True
operations = [iter_ops[Identifier('values')]]
else: # pair iterator
key_type, value_type = types
iter_ops[Identifier('entries')].is_async_iterator = True
operations = list(iter_ops.values())
return AsyncIterable.IR(key_type=key_type,
value_type=value_type,
operations=operations,
arguments=arguments,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def _build_constant_value(self, node):
assert node.GetClass() == 'Value'
return self._build_literal_constant(node)
def _build_debug_info(self, node):
return DebugInfo(
location=Location(
filepath=node.GetProperty('FILENAME'),
line_number=node.GetProperty('LINENO'),
position=node.GetProperty('POSITION')))
def _build_default_value(self, node):
assert node.GetClass() == 'Default'
return self._build_literal_constant(node)
def _build_extended_attributes(self, node):
def build_extended_attribute(node):
key = node.GetName()
values = node.GetProperty('VALUE', default=None)
arguments = None
name = None
child_nodes = node.GetChildren()
if child_nodes:
assert len(child_nodes) == 1
child = child_nodes[0]
if child.GetClass() == 'Arguments':
arguments = list(
map(build_extattr_argument, child.GetChildren()))
elif child.GetClass() == 'Call':
assert len(child.GetChildren()) == 1
grand_child = child.GetChildren()[0]
assert grand_child.GetClass() == 'Arguments'
# ExtendedAttribute is not designed to represent an
# operation, especially a complicated argument list.
# Discard the arguments.
arguments = ()
name = child.GetName()
else:
assert False
return ExtendedAttribute(
key=key, values=values, arguments=arguments, name=name)
def build_extattr_argument(node):
assert node.GetClass() == 'Argument'
child_nodes = node.GetChildren()
assert len(child_nodes) == 1
assert child_nodes[0].GetClass() == 'Type'
type_node = child_nodes[0]
type_children = type_node.GetChildren()
assert len(type_children) == 1
return (type_children[0].GetName(), node.GetName())
assert node.GetClass() == 'ExtAttributes'
return ExtendedAttributes(
list(
filter(None, map(build_extended_attribute,
node.GetChildren()))))
def _build_inheritance(self, node):
assert node.GetClass() == 'Inherit'
return self._create_ref_to_idl_def(
Identifier(node.GetName()), self._build_debug_info(node))
def _build_is_variadic_argument(self, node):
# idl_parser produces the following tree to indicate an argument is
# variadic.
# Arguments
# := [Argument, Argument, ...]
# Argument
# := [Type, Argument(Name='...')] # Argument inside Argument
assert node.GetClass() == 'Argument'
assert node.GetName() == '...'
return True
def _build_iterable(self, node, interface_identifier):
assert node.GetClass() == 'Iterable'
assert isinstance(interface_identifier, Identifier)
child_nodes = list(node.GetChildren())
extended_attributes = self._take_extended_attributes(child_nodes)
types = list(map(self._build_type, child_nodes))
assert len(types) == 1 or len(types) == 2
if len(types) == 1: # value iterator
key_type, value_type = (None, types[0])
operations = None
else: # pair iterator
key_type, value_type = types
iter_ops = self._create_iterable_operations(
node, interface_identifier, extended_attributes)
iter_ops[Identifier('entries')].is_iterator = True
operations = list(iter_ops.values())
return Iterable.IR(key_type=key_type,
value_type=value_type,
operations=operations,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def _build_literal_constant(self, node):
assert not node.GetChildren()
type_token = node.GetProperty('TYPE')
value_token = node.GetProperty('VALUE')
debug_info = self._build_debug_info(node)
factory = self._idl_type_factory
if type_token == 'NULL':
idl_type = factory.nullable_type(
inner_type=factory.simple_type(
name='any', debug_info=debug_info),
debug_info=debug_info)
assert value_token == 'NULL'
value = None
literal = 'null'
elif type_token == 'boolean':
idl_type = factory.simple_type(
name='boolean', debug_info=debug_info)
assert isinstance(value_token, bool)
value = value_token
literal = 'true' if value else 'false'
elif type_token == 'integer':
idl_type = factory.simple_type(name='long', debug_info=debug_info)
assert isinstance(value_token, str)
value = int(value_token, base=0)
literal = value_token
elif type_token == 'float':
idl_type = factory.simple_type(
name='double', debug_info=debug_info)
assert isinstance(value_token, str)
value = float(value_token)
literal = value_token
elif type_token == 'DOMString':
idl_type = factory.simple_type(
name='DOMString', debug_info=debug_info)
assert isinstance(value_token, str)
value = value_token
literal = '"{}"'.format(value)
elif type_token == 'sequence':
idl_type = factory.sequence_type(
element_type=factory.simple_type(
name='any', debug_info=debug_info),
debug_info=debug_info)
assert value_token == '[]'
value = []
literal = '[]'
elif type_token == 'dictionary':
idl_type = factory.simple_type(
name='object', debug_info=debug_info)
assert value_token == '{}'
value = dict()
literal = '{}'
else:
assert False, "Unknown literal type: {}".format(type_token)
return LiteralConstant(idl_type=idl_type, value=value, literal=literal)
def _build_maplike(self, node, interface_identifier):
assert node.GetClass() == 'Maplike'
assert isinstance(interface_identifier, Identifier)
types = list(map(self._build_type, node.GetChildren()))
assert len(types) == 2
key_type, value_type = types
is_readonly = bool(node.GetProperty('READONLY'))
attributes = [
self._create_attribute(
Identifier('size'),
'unsigned long',
is_readonly=True,
node=node),
]
iter_map = self._create_iterable_operations(node, interface_identifier)
iter_map[Identifier('entries')].is_iterator = True
iter_ops = list(iter_map.values())
read_ops = [
self._create_operation(Identifier('get'),
arguments=self._create_arguments([
(Identifier('key'), key_type),
]),
return_type='any',
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'getForBinding',
},
node=node),
self._create_operation(Identifier('has'),
arguments=self._create_arguments([
(Identifier('key'), key_type),
]),
return_type='boolean',
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'hasForBinding',
},
node=node),
]
write_ops = [
self._create_operation(
Identifier('set'),
arguments=self._create_arguments([
(Identifier('key'), key_type),
(Identifier('value'), value_type),
]),
return_type=interface_identifier,
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'setForBinding',
},
node=node),
self._create_operation(
Identifier('delete'),
arguments=self._create_arguments([
(Identifier('key'), key_type),
]),
return_type='boolean',
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'deleteForBinding',
},
node=node),
self._create_operation(
Identifier('clear'),
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'clearForBinding',
},
node=node),
]
for op in write_ops:
op.is_optionally_defined = True
if is_readonly:
operations = iter_ops + read_ops
else:
operations = iter_ops + read_ops + write_ops
return Maplike.IR(
key_type=key_type,
value_type=value_type,
is_readonly=is_readonly,
attributes=attributes,
operations=operations,
debug_info=self._build_debug_info(node))
def _build_setlike(self, node, interface_identifier):
assert node.GetClass() == 'Setlike'
assert isinstance(interface_identifier, Identifier)
types = list(map(self._build_type, node.GetChildren()))
assert len(types) == 1
value_type = types[0]
is_readonly = bool(node.GetProperty('READONLY'))
attributes = [
self._create_attribute(
Identifier('size'),
'unsigned long',
is_readonly=True,
node=node),
]
iter_map = self._create_iterable_operations(node, interface_identifier)
iter_map[Identifier('values')].is_iterator = True
iter_ops = list(iter_map.values())
read_ops = [
self._create_operation(
Identifier('has'),
arguments=self._create_arguments([
(Identifier('value'), value_type),
]),
return_type='boolean',
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'hasForBinding',
},
node=node),
]
write_ops = [
self._create_operation(
Identifier('add'),
arguments=self._create_arguments([
(Identifier('value'), value_type),
]),
return_type=interface_identifier,
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'addForBinding',
},
node=node),
self._create_operation(
Identifier('delete'),
arguments=self._create_arguments([
(Identifier('value'), value_type),
]),
return_type='boolean',
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'deleteForBinding',
},
node=node),
self._create_operation(
Identifier('clear'),
extended_attributes={
'CallWith': 'ScriptState',
'RaisesException': None,
'ImplementedAs': 'clearForBinding',
},
node=node),
]
for op in write_ops:
op.is_optionally_defined = True
if is_readonly:
operations = iter_ops + read_ops
else:
operations = iter_ops + read_ops + write_ops
return Setlike.IR(
value_type=value_type,
is_readonly=is_readonly,
attributes=attributes,
operations=operations,
debug_info=self._build_debug_info(node))
def _build_stringifier(self, node):
# There are three forms of stringifier declaration;
# a. [ExtAttrs] stringifier;
# b. [ExtAttrs] stringifier DOMString foo();
# c. [ExtAttrs] stringifier attribute DOMString bar;
# and we apply [ExtAttrs] to an operation in cases a and b, or to an
# attribute in case c.
assert node.GetClass() == 'Stringifier'
child_nodes = node.GetChildren()
extended_attributes = self._take_extended_attributes(child_nodes)
assert len(child_nodes) <= 1
member = None
if len(child_nodes) == 1:
member = self._build_interface_member(
child_nodes[0],
fallback_extended_attributes=extended_attributes)
extended_attributes = None
operation = member if isinstance(member, Operation.IR) else None
attribute = member if isinstance(member, Attribute.IR) else None
if operation is None:
return_type = self._idl_type_factory.simple_type(
name='DOMString', debug_info=self._build_debug_info(node))
operation = Operation.IR(
identifier=Identifier(''),
arguments=[],
return_type=return_type,
extended_attributes=extended_attributes,
component=self._component,
debug_info=self._build_debug_info(node))
operation.is_stringifier = True
if attribute:
operation.stringifier_attribute = attribute.identifier
return (operation, attribute)
else:
return (operation, )
def _build_type(self,
node,
is_optional=False,
is_variadic=False,
extended_attributes=None):
assert node.GetClass() == 'Type'
assert not (is_optional and is_variadic)
idl_type = self._build_type_internal(
node.GetChildren(),
is_optional=is_optional,
extended_attributes=extended_attributes)
if node.GetProperty('NULLABLE'):
idl_type = self._idl_type_factory.nullable_type(
idl_type,
is_optional=is_optional,
debug_info=self._build_debug_info(node))
if is_variadic:
idl_type = self._idl_type_factory.variadic_type(
idl_type, debug_info=self._build_debug_info(node))
return idl_type
def _build_type_internal(self,
nodes,
is_optional=False,
extended_attributes=None):
"""
Args:
nodes: The child nodes of a 'Type' node.
"""
def build_frozen_array_type(node, extended_attributes):
assert len(node.GetChildren()) == 1
return self._idl_type_factory.frozen_array_type(
element_type=self._build_type(node.GetChildren()[0]),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_observable_array_type(node, extended_attributes):
assert len(node.GetChildren()) == 1
return self._idl_type_factory.observable_array_type(
element_type=self._build_type(node.GetChildren()[0]),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_promise_type(node, extended_attributes):
assert len(node.GetChildren()) == 1
return self._idl_type_factory.promise_type(
result_type=self._build_type(node.GetChildren()[0]),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_union_type(node, extended_attributes):
return self._idl_type_factory.union_type(
member_types=list(map(self._build_type, node.GetChildren())),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_record_type(node, extended_attributes):
key_node, value_node = node.GetChildren()
return self._idl_type_factory.record_type(
# 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]),
value_type=self._build_type(value_node),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_reference_type(node, extended_attributes):
return self._idl_type_factory.reference_type(
Identifier(node.GetName()),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_sequence_type(node, extended_attributes):
return self._idl_type_factory.sequence_type(
element_type=self._build_type(node.GetChildren()[0]),
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
def build_simple_type(node, extended_attributes):
name = node.GetName()
if name is None:
assert node.GetClass() in ('Any', 'Undefined')
name = node.GetClass().lower()
if node.GetProperty('UNRESTRICTED'):
name = 'unrestricted {}'.format(name)
return self._idl_type_factory.simple_type(
name=name,
is_optional=is_optional,
extended_attributes=extended_attributes,
debug_info=self._build_debug_info(node))
type_nodes = list(nodes)
ext_attrs1 = extended_attributes
ext_attrs2 = self._take_extended_attributes(type_nodes)
if ext_attrs1 and ext_attrs2:
extended_attributes = ExtendedAttributes(
list(ext_attrs1) + list(ext_attrs2))
else:
extended_attributes = ext_attrs1 or ext_attrs2
assert len(type_nodes) == 1
body_node = type_nodes[0]
buffer_source_types = set([
'ArrayBuffer',
'ArrayBufferView', # Blink-specific ArrayBufferView definition
'DataView',
'Int8Array',
'Int16Array',
'Int32Array',
'BigInt64Array',
'Uint8Array',
'Uint16Array',
'Uint32Array',
'BigUint64Array',
'Uint8ClampedArray',
'Float32Array',
'Float64Array',
])
if body_node.GetName() in buffer_source_types:
return build_simple_type(
body_node, extended_attributes=extended_attributes)
build_functions = {
'Any': build_simple_type,
'FrozenArray': build_frozen_array_type,
'ObservableArray': build_observable_array_type,
'PrimitiveType': build_simple_type,
'Promise': build_promise_type,
'Record': build_record_type,
'Sequence': build_sequence_type,
'StringType': build_simple_type,
'Typeref': build_reference_type,
'Undefined': build_simple_type,
'UnionType': build_union_type,
}
return build_functions[body_node.GetClass()](
body_node, extended_attributes=extended_attributes)
def _create_arguments(self, args):
"""
Constructs a list of new instances of Argument.
Args:
args: A list of argument parameters. Each argument parameter is
a list of argument identifier, type name in str, and optional
default value in str.
"""
assert isinstance(args, (list, tuple))
arguments = []
index = 0
for arg in args:
assert isinstance(arg, (list, tuple))
assert len(arg) == 2 or len(arg) == 3
identifier = arg[0]
if isinstance(arg[1], str):
idl_type = self._create_type(
arg[1], is_optional=(len(arg) == 3))
else:
idl_type = arg[1]
default_value = None
if len(arg) == 3:
default_value = self._create_literal_constant(arg[2])
arguments.append(
Argument.IR(
identifier,
index=index,
idl_type=idl_type,
default_value=default_value))
index += 1
return arguments
def _create_async_iterable_operations(self, node, interface_identifier,
arguments, extended_attributes):
"""
Constructs a set of async iterable operations.
https://webidl.spec.whatwg.org/#define-the-asynchronous-iteration-methods
"""
def make_ext_attrs(key_values):
return ExtendedAttributes(
list(extended_attributes or []) +
list(self._create_extended_attributes(key_values)))
return {
Identifier('entries'):
self._create_operation(
Identifier('entries'),
arguments=make_copy(arguments),
return_type=AsyncIterator.identifier_for(interface_identifier),
extended_attributes=make_ext_attrs({
'CallWith':
'ScriptState',
'RaisesException':
None,
'ImplementedAs':
'entriesForBinding',
}),
node=node),
Identifier('keys'):
self._create_operation(
Identifier('keys'),
arguments=make_copy(arguments),
return_type=AsyncIterator.identifier_for(interface_identifier),
extended_attributes=make_ext_attrs({
'CallWith':
'ScriptState',
'RaisesException':
None,
'ImplementedAs':
'keysForBinding',
}),
node=node),
Identifier('values'):
self._create_operation(
Identifier('values'),
arguments=make_copy(arguments),
return_type=AsyncIterator.identifier_for(interface_identifier),
extended_attributes=make_ext_attrs({
'CallWith':
'ScriptState',
'RaisesException':
None,
'ImplementedAs':
'valuesForBinding',
}),
node=node),
}
def _create_attribute(self,
identifier,
idl_type,
is_readonly=False,
extended_attributes=None,
node=None):
"""Constructs a new Attribute.IR from simple parameters."""
if isinstance(idl_type, str):
idl_type = self._create_type(idl_type)
if isinstance(extended_attributes, dict):
extended_attributes = self._create_extended_attributes(
extended_attributes)
debug_info = self._build_debug_info(node) if node else None
return Attribute.IR(
identifier,
idl_type=idl_type,
is_readonly=is_readonly,
extended_attributes=extended_attributes,
component=self._component,
debug_info=debug_info)
def _create_extended_attributes(self, key_values):
"""
Constructs a new ExtendedAttributes from a dict of key and values.
"""
assert isinstance(key_values, dict)
return ExtendedAttributes([
ExtendedAttribute(key=key, values=values)
for key, values in key_values.items()
])
def _create_iterable_operations(self,
node,
interface_identifier,
extended_attributes=None):
"""
Constructs a set of iterable operations.
https://webidl.spec.whatwg.org/#define-the-iteration-methods
"""
def make_ext_attrs(key_values):
return ExtendedAttributes(
list(extended_attributes or []) +
list(self._create_extended_attributes(key_values)))
return {
Identifier('forEach'):
self._create_operation(Identifier('forEach'),
arguments=self._create_arguments([
(Identifier('callback'),
Identifier('ForEachIteratorCallback')),
(Identifier('thisArg'), 'any', 'null'),
]),
extended_attributes=make_ext_attrs({
'CallWith':
('ScriptState', 'ThisValue'),
'RaisesException':
None,
'ImplementedAs':
'forEachForBinding',
}),
node=node),
Identifier('entries'):
self._create_operation(
Identifier('entries'),
return_type=SyncIterator.identifier_for(interface_identifier),
extended_attributes=make_ext_attrs({
'CallWith':
'ScriptState',
'RaisesException':
None,
'ImplementedAs':
'entriesForBinding',
}),
node=node),
Identifier('keys'):
self._create_operation(
Identifier('keys'),
return_type=SyncIterator.identifier_for(interface_identifier),
extended_attributes=make_ext_attrs({
'CallWith':
'ScriptState',
'RaisesException':
None,
'ImplementedAs':
'keysForBinding',
}),
node=node),
Identifier('values'):
self._create_operation(
Identifier('values'),
return_type=SyncIterator.identifier_for(interface_identifier),
extended_attributes=make_ext_attrs({
'CallWith':
'ScriptState',
'RaisesException':
None,
'ImplementedAs':
'valuesForBinding',
}),
node=node),
}
def _create_literal_constant(self, token):
factory = self._idl_type_factory
if token == 'null':
return LiteralConstant(
idl_type=factory.nullable_type(
inner_type=factory.simple_type(name='any')),
value=None,
literal='null')
else:
assert False
def _create_operation(self,
identifier,
arguments=None,
return_type=None,
extended_attributes=None,
node=None):
"""Constructs a new Operation.IR from simple parameters."""
if not return_type:
return_type = self._create_type('undefined')
elif isinstance(return_type, str):
return_type = self._create_type(return_type)
if isinstance(extended_attributes, dict):
extended_attributes = self._create_extended_attributes(
extended_attributes)
debug_info = self._build_debug_info(node) if node else None
return Operation.IR(
identifier,
arguments=(arguments or []),
return_type=return_type,
extended_attributes=extended_attributes,
component=self._component,
debug_info=debug_info)
def _create_type(self, keyword_or_identifier, **kwargs):
"""Constructs a new IdlType from a type keyword or identifier."""
name = keyword_or_identifier
if isinstance(name, Identifier):
return self._idl_type_factory.reference_type(name, **kwargs)
elif isinstance(name, str):
return self._idl_type_factory.simple_type(name, **kwargs)
else:
assert False
def _take_and_build(self, node_class, build_func, node_list, **kwargs):
"""
Takes a node of |node_class| from |node_list| if any, and then builds
and returns an IR. The processed node is removed from |node_list|.
Returns None if not found.
"""
for node in node_list:
if node.GetClass() == node_class:
node_list.remove(node)
return build_func(node, **kwargs)
return None
def _take_arguments(self, node_list):
return self._take_and_build('Arguments', self._build_arguments,
node_list)
def _take_async_iterable(self, node_list, **kwargs):
return self._take_and_build('AsyncIterable',
self._build_async_iterable, node_list,
**kwargs)
def _take_constant_value(self, node_list):
return self._take_and_build('Value', self._build_constant_value,
node_list)
def _take_default_value(self, node_list):
return self._take_and_build('Default', self._build_default_value,
node_list)
def _take_extended_attributes(self, node_list):
return self._take_and_build('ExtAttributes',
self._build_extended_attributes, node_list)
def _take_inheritance(self, node_list):
return self._take_and_build('Inherit', self._build_inheritance,
node_list)
def _take_is_variadic_argument(self, node_list):
return self._take_and_build(
'Argument', self._build_is_variadic_argument, node_list)
def _take_iterable(self, node_list, **kwargs):
return self._take_and_build('Iterable', self._build_iterable,
node_list, **kwargs)
def _take_maplike(self, node_list, **kwargs):
return self._take_and_build('Maplike', self._build_maplike, node_list,
**kwargs)
def _take_setlike(self, node_list, **kwargs):
return self._take_and_build('Setlike', self._build_setlike, node_list,
**kwargs)
def _take_stringifier(self, node_list):
return self._take_and_build('Stringifier', self._build_stringifier,
node_list)
def _take_type(self, node_list, **kwargs):
return self._take_and_build('Type', self._build_type, node_list,
**kwargs)
Codebase Browser
chromium