def test_replace_as_expression_restrictions(self):
template = """
foo(a)
bar(b)
"""
with self.assertRaises(ValueError):
templates.replace_as_expression(template)
def visit_Call(self, node):
node = self.generic_visit(node)
if not hasattr(self.overload.module, 'call'):
return node
if self.is_overload_call(node):
return node
starred_arg = None
normal_args = []
for a in node.args:
if isinstance(a, gast.Starred):
assert starred_arg is None, 'Multiple *args should be impossible.'
starred_arg = a
else:
normal_args.append(a)
if starred_arg is None:
args = templates.replace_as_expression('(args,)', args=normal_args)
else:
args = templates.replace_as_expression('(args,) + tuple(stararg)',
stararg=starred_arg.value,
args=normal_args)
kwargs_arg = None
normal_keywords = []
for k in node.keywords:
if k.arg is None:
assert kwargs_arg is None, 'Multiple **kwargs should be impossible.'
kwargs_arg = k
else:
normal_keywords.append(k)
if kwargs_arg is None:
kwargs = ast_util.keywords_to_dict(normal_keywords)
else:
kwargs = templates.replace_as_expression(
'dict(kwargs, **keywords)',
kwargs=kwargs_arg.value,
keywords=ast_util.keywords_to_dict(normal_keywords))
template = """
overload.call(func, args, kwargs)
"""
node = templates.replace_as_expression(
template,
overload=self.overload.symbol_name,
func=node.func,
args=args,
kwargs=kwargs)
return node
def _make_lambda_nodes(self, lst):
lambda_nodes = []
for y in lst:
lambda_node = templates.replace_as_expression('lambda: y', y=y)
lambda_nodes.append(lambda_node)
return lambda_nodes
def test_replace_as_expression(self):
template = """
foo(a)
"""
node = templates.replace_as_expression(template, foo='bar', a='baz')
self.assertIsInstance(node, gast.Call)
self.assertEqual(node.func.id, 'bar')
self.assertEqual(node.args[0].id, 'baz')
def visit_Name(self, node):
node = self.generic_visit(node)
if not hasattr(self.overload.module, 'read'):
return node
if self.scope.should_virtualize(node.id):
node = templates.replace_as_expression(
'overload.read(id)', overload=self.overload.symbol_name, id=node.id)
return node
def _overload_Not(self, node):
assert isinstance(node, gast.UnaryOp)
node = self.generic_visit(node)
node = templates.replace_as_expression(
'overload.not_(x)',
overload=self.overload.symbol_name,
x=node.operand)
return node
def _handle_boolop(self, node, func):
assert isinstance(node, gast.BoolOp)
node = self.generic_visit(node)
lambda_nodes = self._make_lambda_nodes(node.values[1:])
node = templates.replace_as_expression(
'overload.func(x, (operands,))',
func=func,
overload=self.overload.symbol_name,
x=node.values[0],
operands=lambda_nodes)
return node
def test_function_call_in_list(self):
template = """
foo(bar)
"""
source = parsing.parse_expression('[a(b(1))]')
templates.replace_as_expression(template, bar=source)
