def make_assign_opt_unpack(i, bytecode):
store_exprs = []
value_exprs = []
store_state, value_state = True, False
while i >= 0:
op, arg = bytecode[i][2], bytecode[i][3]
if store_state:
if op == ROT_TWO:
prev_op = bytecode[i - 1][2] if i > 0 else -1
if prev_op == ROT_THREE:
i -= 1
value_state = True
store_state = False
elif op in STORE_OPCODES:
i, store_stmt = Statement.make_expr(i, bytecode, context=_ast.Store())
store_exprs.insert(0, store_stmt)
elif value_state:
i, value_stmt = Statement.make_expr(i, bytecode)
value_exprs.insert(0, value_stmt)
i -= 1
store_exprs = _ast.Tuple(store_exprs, _ast.Store())
if not isinstance(value_exprs, _ast.AST):
value_exprs = _ast.Tuple(value_exprs, _ast.Load())
return i, _ast.Assign([store_exprs], value_exprs)
class ConstructorMutableAttribsLineNumberFixture:
definition_is_none = None
definition_is_not_a_function = _ast.Pass
constructor_with_empty_body = _ast.FunctionDef(name='__init__', body=[])
try:
constructor_with_immutable = _ast.FunctionDef(
name='__init__',
body=[
_ast.Assign(lineno=1, value=_ast.Tuple(elts=[1, 2, 3])),
_ast.Assign(lineno=2, value=_ast.Str(s='a')),
],
)
except (AttributeError):
constructor_with_immutable = _ast.FunctionDef(
name='__init__',
body=[
_ast.Assign(lineno=1, value=_ast.Tuple(elts=[1, 2, 3])),
_ast.Assign(lineno=3, value=_ast.JoinedStr(values=None)),
],
)
constructor_with_mutable = _ast.FunctionDef(
name='__init__',
body=[
_ast.Assign(lineno=1, value=_ast.List(elts=[1, 2, 3])),
_ast.Assign(lineno=2, value=_ast.Set(elts=[1, 2, 3])),
_ast.Assign(lineno=3, value=_ast.Dict(keys=['a'])),
],
)
def make_assign_unpack(i, bytecode, unpack_num=-1):
if unpack_num < 1:
logger.error("Could not find the number of unpacked items. ")
return i, None
store_exprs = []
value_exprs = []
store_state, value_state = True, False
while i >= 0:
op, arg = bytecode[i][2], bytecode[i][3]
if store_state:
if op == UNPACK_SEQUENCE:
store_state = False
prev_op = bytecode[i - 1][2] if i > 0 else -1
if prev_op == BUILD_TUPLE:
value_state = True
else:
i, value_exprs = Statement.make_expr(i - 1, bytecode)
break
elif op in STORE_OPCODES:
i, store_stmt = Statement.make_expr(i, bytecode, context=_ast.Store())
store_exprs.insert(0, store_stmt)
elif value_state:
i, value_stmt = Statement.make_expr(i, bytecode)
value_exprs.insert(0, value_stmt)
i -= 1
store_exprs = _ast.Tuple(store_exprs, _ast.Store())
if not isinstance(value_exprs, _ast.AST):
value_exprs = _ast.Tuple(value_exprs, _ast.Load())
return i, _ast.Assign([store_exprs], value_exprs)
def ROT_TWO(self, instr):
one = self.ast_stack.pop()
two = self.ast_stack.pop()
if self.ilst[0].opname == 'STORE_NAME':
kw = dict(lineno=instr.lineno, col_offset=0)
stores = []
while self.ilst[0].opname == 'STORE_NAME':
stores.append(self.ilst.pop(0))
assert len(stores) <= 3, stores
elts_load = [one, two]
if len(stores) == 3:
elts_load.insert(0, self.ast_stack.pop())
tup_load = _ast.Tuple(elts=elts_load[::-1], ctx=_ast.Load(), **kw)
elts_store = [
_ast.Name(id=store.arg, ctx=_ast.Store(), **kw)
for store in stores
]
tup_store = _ast.Tuple(elts=elts_store, ctx=_ast.Store(), **kw)
assgn = _ast.Assign(value=tup_load, targets=[tup_store], **kw)
self.ast_stack.append(assgn)
# self.ast_stack.append(tup_store)
else:
self.ast_stack.append(one)
self.ast_stack.append(two)
def UNPACK_SEQUENCE(self, instr):
nargs = instr.oparg
nodes = []
ast_tuple = _ast.Tuple(elts=nodes,
ctx=_ast.Store(),
lineno=instr.lineno,
col_offset=0)
for i in range(nargs):
nex_instr = self.ilst.pop(0)
self.ast_stack.append(None)
self.visit(nex_instr)
node = self.ast_stack.pop()
nodes.append(node.targets[0])
expr = self.ast_stack.pop()
if isinstance(expr, _ast.Assign):
assgn = expr
assgn.targets.append(ast_tuple)
value_dup = self.ast_stack.pop()
assert cmp_ast(assgn.value, value_dup)
else:
assgn = _ast.Assign(targets=[ast_tuple],
value=expr,
lineno=instr.lineno,
col_offset=0)
self.ast_stack.append(assgn)
def Tuple(*items, **kwargs):
"""Creates an _ast.Tuple node.
Automatically adjusts inner ctx attrs.
Args:
*items: The items in the list.
**kwargs: Only recognized kwarg is 'ctx_type', which controls the
ctx type of the list. See CtxEnum.
Returns:
An _ast.Tuple node.
"""
ctx_type = kwargs.pop('ctx_type', CtxEnum.LOAD)
new_items = []
for item in items:
if isinstance(item, str):
new_items.append(_WrapWithName(item))
else:
new_items.append(item)
for item in new_items:
if isinstance(item, _ast.Name):
item.ctx = GetCtx(ctx_type)
elif isinstance(item, _ast.Attribute):
name_node = _LeftmostNodeInDotVar(item)
name_node.ctx = GetCtx(ctx_type)
ctx = GetCtx(ctx_type)
return _ast.Tuple(elts=new_items, ctx=ctx)
def visit_Tuple(self, node):
if self.randomize():
elements = [self.visit(node.elts[0])]
for element in node.elts[1:]:
if self.randomize():
elements.append(self.visit(element))
if self.randomize():
for element in node.elts:
if self.randomize():
elements.append(self.visit(element))
return ast.copy_location(_ast.Tuple(elts=elements), node)
else:
return node
def BUILD_TUPLE(self, instr):
nitems = instr.oparg
nodes = []
list_ = _ast.Tuple(elts=nodes, ctx=_ast.Load(), lineno=instr.lineno, col_offset=0)
for i in range(nitems):
nodes.insert(0, self.ast_stack.pop())
if any([item == 'CLOSURE' for item in nodes]):
assert all([item == 'CLOSURE' for item in nodes])
return
self.ast_stack.append(list_)
def make_const(i, bytecode):
arg = bytecode[i][3]
if isinstance(arg, basestring):
return i, _ast.Str(arg)
elif isinstance(arg, int) or isinstance(arg, float) or isinstance(arg, long):
return i, _ast.Num(arg)
elif isinstance(arg, dict):
return i, _ast.Dict(arg.keys(), arg.values())
elif isinstance(arg, set):
return i, _ast.Dict(arg)
elif isinstance(arg, tuple):
return i, _ast.Tuple(arg, _ast.Load())
elif isinstance(arg, list):
return i, _ast.List(arg, _ast.Load())
elif isinstance(arg, bytes):
return i, _ast.Bytes(arg)
return i, None
def make_const(arg, lineno=0, col_offset=0):
kw = {'lineno': lineno, 'col_offset': col_offset}
if isinstance(arg, str):
const = _ast.Str(s=arg, **kw)
elif isinstance(arg, (int, float, complex)):
const = _ast.Num(n=arg, **kw)
elif arg is None:
const = _ast.Name(id='None', ctx=_ast.Load(), **kw)
elif isinstance(arg, tuple):
elts = []
for item in arg:
elts.append(make_const(item, **kw))
const = _ast.Tuple(elts=elts, ctx=_ast.Load(), **kw)
else:
const = arg
return const
def make_assign_chained(i, bytecode):
store_exprs = []
value_exprs = []
store_state, value_state = True, False
while i >= 0:
op, arg = bytecode[i][2], bytecode[i][3]
if store_state:
if op == DUP_TOP:
prev_op = bytecode[i - 1][2] if i > 0 else -1
if prev_op not in STORE_OPCODES:
value_state = True
store_state = False
elif op in STORE_OPCODES:
i, store_stmt = Statement.make_expr(i, bytecode, context=_ast.Store())
store_exprs.insert(0, store_stmt)
elif value_state:
i, value_exprs = Statement.make_expr(i, bytecode)
break
i -= 1
store_exprs = _ast.Tuple(store_exprs, _ast.Store())
return i, _ast.Assign([store_exprs], value_exprs)
def tuple_expr(elts: List[_ast.expr], ctx: _ast.expr_context) -> _ast.Tuple:
return _ast.Tuple(elts=elts, ctx=ctx)
def test_return_value_is_filled_tuple():
# when method return ('1')
assert ReturnedExpression(
_ast.Return(value=_ast.Tuple(elts=['1'], ctx=_ast.Load()),
lineno=1), ).value_not_none() is True
def test_return_value_is_empty_tuple():
# when method return ()
assert ReturnedExpression(
_ast.Return(value=_ast.Tuple(elts=[], ctx=_ast.Load()),
lineno=1), ).value_not_none() is False
def STORE_NAME(self, instr):
value = self.pop_ast_item()
value = self.process_ifexpr(value)
if isinstance(value, _ast.Import):
if value.from_:
assert isinstance(self._ast_stack[-1], _ast.ImportFrom)
from_ = self.pop_ast_item()
as_name = instr.arg
name = from_.names[0].name
if as_name != name:
from_.names[0].asname = as_name
self.push_ast_item(from_)
else:
as_name = instr.arg
if value.names[0].asname is None:
base_name = value.names[0].name.split('.')[0]
if base_name != as_name:
value.names[0].asname = as_name
self.push_ast_item(value)
elif isinstance(value, (_ast.Attribute)) and isinstance(
value.value, (_ast.Import)):
asname = instr.arg
value = value.value
value.names[0].asname = asname
self.push_ast_item(value)
elif isinstance(value, (_ast.ClassDef, _ast.FunctionDef)):
as_name = instr.arg
value.name = as_name
self.push_ast_item(value)
elif isinstance(value, _ast.AugAssign):
self.push_ast_item(value)
elif isinstance(value, _ast.Assign):
_ = self.pop_ast_item()
assname = _ast.Name(instr.arg,
_ast.Store(),
lineno=instr.lineno,
col_offset=0)
if _ is value.value or isinstance(_, _ast.Assign):
value.targets.append(assname)
else:
if not isinstance(value.targets, _ast.Tuple):
value.targets = [_ast.Tuple(value.targets, _ast.Store())]
value.value = _ast.Tuple([value.value], _ast.Load())
value.targets[0].lineno = value.targets[0].elts[0].lineno
value.targets[0].col_offset = value.targets[0].elts[
0].col_offset
value.value.lineno = value.value.elts[0].lineno
value.value.col_offset = value.value.elts[0].col_offset
value.targets[0].elts.append(assname)
value.value.elts.append(_)
self.push_ast_item(value)
else:
assname = _ast.Name(instr.arg,
_ast.Store(),
lineno=instr.lineno,
col_offset=0)
assign = _ast.Assign(targets=[assname],
value=value,
lineno=instr.lineno,
col_offset=0)
self.push_ast_item(assign)
