def test_unify_ir0_certain_nontrivial_with_variadic_type_variable_matches_empty_list_suffix(
):
result = _unify([
ir0.FunctionTypeExpr(type_literal('int'),
arg_exprs=[type_literal('float')])
], [
ir0.FunctionTypeExpr(type_literal('int'),
arg_exprs=[
type_literal('float'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(
cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True))
])
],
expr_variables=set(),
pattern_variables={'Ts'})
assert result.kind == UnificationResultKind.CERTAIN
assert result.value_by_pattern_variable == []
assert result.value_by_expanded_pattern_variable == [
(ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True)), []),
]
def test_unify_ir0_certain_nontrivial_with_variadic_type_variable() -> None:
result = _unify(
(ir0.FunctionTypeExpr(
type_literal('int'),
arg_exprs=(type_literal('float'), type_literal('double'),
local_type_literal('T'), type_literal('char'),
type_literal('void'))), ),
(ir0.FunctionTypeExpr(
type_literal('int'),
arg_exprs=(type_literal('float'), type_literal('double'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(
cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True)), type_literal('void'))), ),
expr_variables={'T'},
pattern_variables={'Ts'})
assert result.kind == UnificationResultKind.CERTAIN
assert result.value_by_pattern_variable == ()
assert result.value_by_expanded_pattern_variable == (
(ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True)),
(local_type_literal('T'), type_literal('char'))), )
def test_unify_ir0_certain_nontrivial_with_variadic_type_variable_does_not_match(
) -> None:
result = _unify(
(ir0.FunctionTypeExpr(type_literal('int'), arg_exprs=()), ),
(ir0.FunctionTypeExpr(type_literal('int'),
arg_exprs=(
type_literal('float'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(
cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True)),
)), ),
expr_variables=set(),
pattern_variables={'Ts'})
assert result.kind == UnificationResultKind.IMPOSSIBLE
def test_unify_ir0_variadic_type_variable_matches_multiple_variadics():
result = _unify([
ir0.FunctionTypeExpr(
type_literal('int'),
arg_exprs=[
type_literal('float'),
type_literal('double'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True)),
type_literal('char'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Us',
expr_type=ir0.TypeType(),
is_variadic=True)),
type_literal('void')
])
], [
ir0.FunctionTypeExpr(type_literal('int'),
arg_exprs=[
type_literal('float'),
type_literal('double'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(
cpp_type='Vs',
expr_type=ir0.TypeType(),
is_variadic=True)),
type_literal('void')
])
],
expr_variables={'Ts', 'Us'},
pattern_variables={'Vs'})
assert result.kind == UnificationResultKind.CERTAIN
assert result.value_by_pattern_variable == []
assert result.value_by_expanded_pattern_variable == [
(ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Vs',
expr_type=ir0.TypeType(),
is_variadic=True)),
[
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Ts',
expr_type=ir0.TypeType(),
is_variadic=True)),
type_literal('char'),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(cpp_type='Us',
expr_type=ir0.TypeType(),
is_variadic=True))
]),
]
'TemplateInstantiation (no args)',
'TemplateInstantiation (1 arg)',
'ClassMemberAccess',
])
def test_unify_ir0_trivial_term_equality(expr_generator):
result = _unify([expr_generator()], [expr_generator()],
expr_variables=set(),
pattern_variables=set())
assert result.kind == UnificationResultKind.CERTAIN
assert result.value_by_pattern_variable == []
assert result.value_by_expanded_pattern_variable == []
@pytest.mark.parametrize('expr1,expr2', [
(ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(
'Ts', expr_type=ir0.TypeType(), is_variadic=True)),
ir0.VariadicTypeExpansion(
ir0.AtomicTypeLiteral.for_local(
'Us', expr_type=ir0.TypeType(), is_variadic=True))),
])
def test_unify_ir0_term_equality_variadic_type_expansion(expr1, expr2):
result = _unify([expr1], [expr2],
expr_variables={'Ts'},
pattern_variables={'Us'})
assert result.kind == UnificationResultKind.CERTAIN
assert result.value_by_pattern_variable == [
(ir0.AtomicTypeLiteral.for_local('Us',
expr_type=ir0.TypeType(),
is_variadic=True),
ir0.AtomicTypeLiteral.for_local('Ts',
# struct TypeListConcat;
#
# template <typename... Ts, typename... Us>
# struct TypeListConcat<List<Ts...>, List<Us...>> {
# using type = List<Ts..., Us...>;
# };
_define_template_with_single_specialization(
name='TypeListConcat',
main_definition_args=[_type_arg_decl('L1'),
_type_arg_decl('L2')],
specialization_args=[
_variadic_type_arg_decl('Ts'),
_variadic_type_arg_decl('Us')
],
patterns=[
_type_list_of(ir0.VariadicTypeExpansion(_local_variadic_type('Ts'))),
_type_list_of(ir0.VariadicTypeExpansion(_local_variadic_type('Us')))
],
type_expr=_type_list_of(
ir0.VariadicTypeExpansion(_local_variadic_type('Ts')),
ir0.VariadicTypeExpansion(_local_variadic_type('Us'))))
# template <typename L1, typename L2>
# struct Int64ListConcat;
#
# template <int64_t... ns, int64_t... ms>
# struct Int64ListConcat<Int64List<ns...>, Int64List<ms...>> {
# using type = Int64List<ns..., ms...>;
# };
_define_template_with_single_specialization(
name='Int64ListConcat',
result_element_name='type',
has_error=(error_expr is not None))
# template <typename L1, typename L2>
# struct TypeListConcat;
#
# template <typename... Ts, typename... Us>
# struct TypeListConcat<List<Ts...>, List<Us...>> {
# using type = List<Ts..., Us...>;
# };
_define_template_with_single_specialization(name='TypeListConcat',
main_definition_args=(_type_arg_decl('L1'),
_type_arg_decl('L2')),
specialization_args=(_variadic_type_arg_decl('Ts'),
_variadic_type_arg_decl('Us')),
patterns=(_type_list_of(ir0.VariadicTypeExpansion(_local_variadic_type('Ts'))),
_type_list_of(ir0.VariadicTypeExpansion(_local_variadic_type('Us')))),
type_expr=_type_list_of(ir0.VariadicTypeExpansion(_local_variadic_type('Ts')),
ir0.VariadicTypeExpansion(_local_variadic_type('Us'))))
# template <typename L1, typename L2>
# struct Int64ListConcat;
#
# template <int64_t... ns, int64_t... ms>
# struct Int64ListConcat<Int64List<ns...>, Int64List<ms...>> {
# using type = Int64List<ns..., ms...>;
# };
_define_template_with_single_specialization(name='Int64ListConcat',
main_definition_args=(_type_arg_decl('L1'),
_type_arg_decl('L2')),
specialization_args=(_variadic_int64_arg_decl('ns'),
