class NonAssertMethodAtTestFunctionFixture:
definition_is_none = None
definitions_is_not_a_function = _ast.Pass()
definitions_is_not_a_test_function = _ast.FunctionDef(name='not_a_test')
definitions_with_only_assert = _ast.FunctionDef(name='test',
body=[_ast.Assert()])
definitions_with_code = _ast.FunctionDef(
name='test', body=[_ast.Pass(lineno=1),
_ast.Assert()])
def test_issue793(self):
import _ast as ast
body = ast.Module([
ast.Try([ast.Pass(lineno=2, col_offset=4)],
[ast.ExceptHandler(ast.Name('Exception', ast.Load(),
lineno=3, col_offset=0),
None, [ast.Pass(lineno=4, col_offset=0)],
lineno=4, col_offset=0)],
[], [], lineno=1, col_offset=0)
])
exec(compile(body, '<string>', 'exec'))
class SetterOrGetterDefNamesLineNumbersFixture:
definition_is_none = None
definition_is_pass = _ast.Pass()
name_is_none = _ast.FunctionDef(name=None)
without_setget_keywords = _ast.FunctionDef(name='test')
with_set_keywords = _ast.FunctionDef(name='set_test', lineno=1)
with_get_keywords = _ast.FunctionDef(name='get_test', lineno=2)
class ConstructorFixture:
constructor_without_params = _ast.ClassDef(
name='Test',
body=[
_ast.FunctionDef(
name='__init__',
body=[_ast.Pass()],
),
],
bases=None,
)
empty_class = _ast.ClassDef(
name='Test',
body=[],
bases=None,
)
class_without_constructor = _ast.ClassDef(
name='Test',
body=[
_ast.FunctionDef(
name='some_function',
body=[_ast.Pass()],
),
],
bases=None,
)
class_with_constructor_and_additional_method = _ast.ClassDef(
name='Test',
body=[
_ast.FunctionDef(
name='some_function',
body=[_ast.Pass()],
),
_ast.FunctionDef(
name='__init__',
body=[_ast.Pass()],
),
],
bases=None,
)
class_with_inheritance = _ast.ClassDef(
name='Test',
body=[],
bases=[_ast.ClassDef(name='TestParent')],
)
class SetEncapsulatedAttribsLineNumbersFixture:
definition_is_none = None
definition_is_pass = _ast.Pass()
is_constructor = _ast.FunctionDef(name='__init__')
without_assign = _ast.FunctionDef(name='test', body=[_ast.Pass()])
with_assign_without_self = _ast.FunctionDef(
name='test', body=[
_ast.Pass(),
_ast.Assign(targets=[_ast.Attribute(value=(_ast.Name(id='test')), lineno=1)]),
],
)
with_assign_with_self = _ast.FunctionDef(
name='test', body=[
_ast.Pass(),
_ast.Assign(targets=[_ast.Attribute(value=(_ast.Name(id='self')), lineno=1)]),
],
)
class ReturnedValueFixture:
node_is_none = None
assign_expression_as_input = _ast.Assign(lineno=1)
pass_expression_as_input = _ast.Pass(lineno=1)
plain_expression_as_input = _ast.Expr(lineno=1)
function_body_is_empty = _ast.FunctionDef(lineno=1, body=[])
function_body_without_return_expression = _ast.FunctionDef(
lineno=1,
body=[_ast.Pass(), _ast.Expr(), _ast.Assign],
)
function_body_with_return_expression = _ast.FunctionDef(
lineno=1,
body=[
_ast.Pass(),
_ast.Expr(),
_ast.Assign(),
_ast.Return(lineno=1, value=None)
],
)
class StaticOrPrivateFixture:
definition_is_assign = _ast.Assign()
definition_is_pass = _ast.Pass()
definition_is_expr = _ast.Expr()
empty_decorator_list_and_name = _ast.FunctionDef()
empty_decorator_list = _ast.FunctionDef(name='test')
is_private = _ast.FunctionDef(name='_test')
is_protected = _ast.FunctionDef(name='__test')
is_magic = _ast.FunctionDef(name='__test__')
decorated = _ast.FunctionDef(name='test', decorator_list=['any_decorator'])
is_static = _ast.FunctionDef(
name='test',
decorator_list=[_ast.FunctionDef(id='staticmethod')],
)
def visitFor(self, node):
target = self.visit(node.target)
for_iter = self.visit(node.iter)
self.reduce(node.body)
len_body = len(node.body)
if len_body == 0:
node.body.append(
_ast.Pass(lineno=node.lineno, col_offset=node.col_offset))
self.reduce(node.orelse)
len_orelse = len(node.orelse)
return (len_body == 0) and (len_orelse == 0) and target and for_iter
def remove_unused_assign(root, symbol):
'''
Remove redundant statements.
The statement `a = 1` will be removed::
a = 1
a = 2
The statement `a = 1` will not be removed because `b` depends on it::
a = 1
b = a + 2
a = 2
:param root: ast node
'''
gen = GatherAssignments()
gen.visit(root)
to_remove = []
if symbol not in gen.assign_id_map:
return
assignments = gen.assign_id_map[symbol]
if len(assignments) < 2:
return
for j in range(len(assignments) - 1):
i1 = root.body.index(assignments[j].root)
i2 = root.body.index(assignments[j + 1].root)
body = root.body[i1 + 1:i2]
grapher = GraphGen()
for stmnt in body:
grapher.visit(stmnt)
if symbol not in grapher.used:
to_remove.extend(assignments[j].assignments)
Pass = lambda node: _ast.Pass(lineno=node.lineno,
col_offset=node.col_offset)
for old in to_remove:
replace_nodes(root, old, Pass(old))
node is removable only if all of its children are as well.
'''
throw_away = []
for child in self.children(node):
throw_away.append(self.visit(child))
if self.mode == 'exclusive':
return all(throw_away)
elif self.mode == 'inclusive':
return any(throw_away)
else:
raise TypeError("mode must be one of 'exclusive' or 'inclusive'")
# Helper function to create a pass node with a line number and col_offset
Pass = lambda node: _ast.Pass(lineno=node.lineno, col_offset=node.col_offset)
class PruneVisitor(Visitor):
'''
Visitor to remove ast nodes
:param symbols: set of symbol that are removable.
'''
def __init__(self, symbols, mode='exclusive'):
self.remove_symbols = symbols
if mode not in ['exclusive', 'inclusive']:
raise TypeError("mode must be one of 'exclusive' or 'inclusive'")
def pass_stmt() -> _ast.Pass:
return _ast.Pass()
def Pass():
"""Creates an _ast.Pass node."""
return _ast.Pass()
def split_handlers(self, handlers_blocks):
handlers = []
except_instrs = []
ends = []
while len(handlers_blocks):
instr = handlers_blocks.pop(0)
except_instrs.append(instr)
if (instr.opname == 'COMPARE_OP') and (instr.arg == 'exception match'):
jump = handlers_blocks.pop(0)
assert jump.opname == 'POP_JUMP_IF_FALSE'
next_handler = jump.oparg
instr = handlers_blocks.pop(0)
except_instrs.append(instr)
instr = handlers_blocks.pop(0)
except_instrs.append(instr)
instr = handlers_blocks.pop(0)
except_instrs.append(instr)
assert except_instrs[0].opname == 'DUP_TOP'
assert except_instrs[-3].opname == 'POP_TOP'
assert except_instrs[-1].opname == 'POP_TOP'
exec_stmnt = self.decompile_block(except_instrs[1:-4]).stmnt()
assert len(exec_stmnt) == 1
exc_type = exec_stmnt[0]
if except_instrs[-2].opname == 'STORE_NAME':
exc_name = _ast.Name(id=except_instrs[-2].arg, ctx=_ast.Store(), lineno=except_instrs[-2].lineno, col_offset=0)
else:
assert except_instrs[-2].opname == 'POP_TOP'
exc_name = None
handler_body = []
while len(handlers_blocks):
instr = handlers_blocks.pop(0)
if instr.i == next_handler:
handlers_blocks.insert(0, instr)
break
handler_body.append(instr)
assert handler_body[-1].opname == 'JUMP_FORWARD'
ends.append(handler_body[-1].arg)
exc_body = self.decompile_block(handler_body[:-1]).stmnt()
if not exc_body:
exc_body.append(_ast.Pass(lineno=except_instrs[-2].lineno, col_offset=0))
# is this for python 3?
if py3 and exc_name is not None:
exc_name = exc_name.id
handlers.append(_ast.ExceptHandler(type=exc_type, name=exc_name, body=exc_body, lineno=instr.lineno, col_offset=0))
except_instrs = []
assert except_instrs[-1].opname == 'END_FINALLY'
if len(except_instrs) == 1:
pass
else:
assert except_instrs[0].opname == 'POP_TOP'
assert except_instrs[1].opname == 'POP_TOP'
assert except_instrs[2].opname == 'POP_TOP'
assert except_instrs[-2].opname in ['JUMP_FORWARD', 'JUMP_ABSOLUTE'], except_instrs[-2]
ends.append(except_instrs[-2].arg)
exc_body = self.decompile_block(except_instrs[3:-2]).stmnt()
if not exc_body:
exc_body.append(_ast.Pass(lineno=except_instrs[-2].lineno, col_offset=0))
handlers.append(_ast.ExceptHandler(type=None, name=None, body=exc_body, lineno=except_instrs[0].lineno, col_offset=0))
assert all(e == ends[0] for e in ends)
end = ends[0]
return end, handlers
def build_pass():
add_ast_node(_ast.Pass())
class ConstructorNonAttribsValueLineNumberFixture:
definition_is_none = None
definition__is_not_a_function = _ast.Pass
definitions_is_not_a_constructor = _ast.FunctionDef(name='test', body=[_ast.Expr(lineno=1)])
definitions_consist_of_assign_with_attribute = _ast.FunctionDef(
name='__init__', body=[_ast.Assign(targets=[_ast.Attribute(lineno=2)], lineno=1)],
)
definitions_consist_of_assign_without_attribute = _ast.FunctionDef(
name='__init__', body=[_ast.Assign(targets=[_ast.Expr(lineno=2)], lineno=1)],
)
definitions_consist_of_any_but_not_a_assign = _ast.FunctionDef(name='__init__', body=[_ast.Pass(lineno=3)])
