def test_unify_tuples_one_to_many_tuple_vars(canonicalize):
equations = unify([
((TupleExpansion('x'), ),
(Term('f', ()), TupleExpansion('y'), Term(
'g', ()), TupleExpansion('z'), Term('h', ()))),
], canonicalize)
assert equations == {'x...': '[f(), y..., g(), z..., h()]'}
def test_unify_tuples_zero_to_many_tuple_vars(canonicalize):
equations = unify([
((), (TupleExpansion('y'), TupleExpansion('z'))),
], canonicalize)
assert equations == {
'y...': '[]',
'z...': '[]',
}
def test_unify_tuples_common_suffix(canonicalize):
equations = unify([
((TupleExpansion('z'), 'x', 'y'), (
Term('f', ()),
'k',
'x',
'y',
)),
], canonicalize)
assert equations == {'z...': '[f(), k]'}
def _unpack_if_variable(expr: ir.Expr,
var_names: Set[str],
literal_expr_by_unique_name: MutableMapping[str, ir.AtomicTypeLiteral]):
if isinstance(expr, ir.VariadicTypeExpansion):
return TupleExpansion(_unpack_if_variable(expr.inner_expr, var_names, literal_expr_by_unique_name))
if isinstance(expr, ir.AtomicTypeLiteral) and expr.cpp_type in var_names:
# We keep track of the expr so that we can re-pack this later.
# If there are multiple they must be the same.
if expr.cpp_type in literal_expr_by_unique_name:
assert expr == literal_expr_by_unique_name[expr.cpp_type], '%s vs %s. Detailed:\n%s\n-- vs --\n%s' % (
expr_to_cpp_simple(expr),
expr_to_cpp_simple(literal_expr_by_unique_name[expr.cpp_type]),
ir_to_string(expr),
ir_to_string(literal_expr_by_unique_name[expr.cpp_type]))
else:
literal_expr_by_unique_name[expr.cpp_type] = expr
return expr.cpp_type
else:
return expr
def replace_variables_in_expr(
self, expr: UnificationStrategy.Expr,
replacements: Dict[str, Tuple[UnificationStrategy.Expr, ...]],
expanded_var_replacements: Dict[str, Tuple[UnificationStrategy.Expr,
...]]
) -> UnificationStrategy.Expr:
if isinstance(expr, str):
if expr in replacements:
return replacements[expr]
if expr in expanded_var_replacements:
return expanded_var_replacements[expr]
return expr
if isinstance(expr, TupleExpansion):
return TupleExpansion(
self.replace_variables_in_expr(expr.expr, replacements,
expanded_var_replacements))
return self.term_copy_with_args(
expr,
tuple(
self.replace_variables_in_expr(arg, replacements,
expanded_var_replacements)
for arg in self.get_term_args(expr)))
def test_unify_tuples_many_to_many_tuple_vars_ok_if_same(canonicalize):
equations = unify([
((TupleExpansion('x'), Term('f', ()), TupleExpansion('y')),
(TupleExpansion('x'), Term('f', ()), TupleExpansion('y'))),
], canonicalize)
assert equations == {}
def test_unify_tuples_many_to_many_tuple_vars(canonicalize):
with pytest.raises(UnificationAmbiguousException):
unify([
((TupleExpansion('x'), Term('f', ()), TupleExpansion('y')),
(TupleExpansion('z'), Term('f', ()), TupleExpansion('k'))),
], canonicalize)
def test_unify_tuple_var_with_term(canonicalize):
equations = unify([
(TupleExpansion('x'), (Term('f', ('y', )), )),
], canonicalize)
assert equations == {'x...': '[f(y)]'}
def test_unify_tuple_var_with_empty_tuple(canonicalize):
equations = unify([
(TupleExpansion('x'), ()),
], canonicalize)
assert equations == {'x...': '[]'}
def test_unify_tuple_var_with_tuple_var(canonicalize):
equations = unify([
(TupleExpansion('x'), TupleExpansion('y')),
], canonicalize)
assert equations == {'x': 'y'}