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)