def test_classattrs(self): import ast x = ast.Num() assert x._fields == ('n', ) exc = raises(AttributeError, getattr, x, 'n') assert str(exc.value) == "'Num' object has no attribute 'n'" x = ast.Num(42) assert x.n == 42 exc = raises(AttributeError, getattr, x, 'lineno') assert str(exc.value) == "'Num' object has no attribute 'lineno'" y = ast.Num() x.lineno = y assert x.lineno == y exc = raises(AttributeError, getattr, x, 'foobar') assert str(exc.value) == "'Num' object has no attribute 'foobar'" x = ast.Num(lineno=2) assert x.lineno == 2 x = ast.Num(42, lineno=0) assert x.lineno == 0 assert x._fields == ('n', ) assert x.n == 42 raises(TypeError, ast.Num, 1, 2) raises(TypeError, ast.Num, 1, 2, lineno=0)
def test_node_identity(self): import _ast as ast n1 = ast.Num(1) n3 = ast.Num(3) addop = ast.Add() x = ast.BinOp(n1, addop, n3) assert x.left == n1 assert x.op == addop assert x.right == n3
def visit_For( self, node ): self.generic_visit( node ) if not ( isinstance( node.iter, _ast.Call ) and isinstance( node.iter.func, _ast.Name ) and node.iter.func.id in ['range', 'xrange'] ): raise VerilogTranslationError( 'For loops are only translatable when using range or xrange!\n' 'Please use "for i in range(...)/xrange(...)".', node.lineno ) call = node.iter if len( call.args ) == 1: start = _ast.Num( n=0 ) stop = call.args[0] step = _ast.Num( n=1 ) elif len( call.args ) == 2: start = call.args[0] stop = call.args[1] step = _ast.Num( n=1 ) # TODO: should be an expression elif len( call.args ) == 3: start = call.args[0] stop = call.args[1] step = call.args[2] else: raise VerilogTranslationError( 'An invalid number of arguments provided to (x)range function!\n', node.lineno ) # Must know if the step is negative or positive in order to set the # correct bound check. This is because of Python's range behavior. try: if hasattr( step, '_object' ): step_val = step._object elif hasattr( step, 'n' ): step_val = step.n assert step_val != 0 except (UnboundLocalError,AssertionError): raise VerilogTranslationError( 'An error occurred when translating a "for loop"!\n' 'The "step" parameter to range must be a constant integer value != 0!', node.lineno ) node.iter = _ast.Slice( lower=start, upper=stop, step=step ) node.iter.lt_gt = '<' if step_val > 0 else '>' return node
def visit_Expr(self, expression_node): value = expression_node.value if not isinstance(value, _ast.BinOp) or not isinstance( value.op, _ast.Mult) or not isinstance(value.right, _ast.Call): return expression_node number_of_invocations = value.left if MockAssertionTransformer._value_is_a_wildcard( number_of_invocations): number_of_invocations = _ast.Num(n=-1) target_mock = value.right.func.value target_method = _ast.Str(s=value.right.func.attr) list_of_arguments = [ MockAssertionTransformer._transform_arg_if_wildcard(x) for x in value.right.args ] spread_list_of_arguments = _ast.Starred(value=_ast.List( elts=list_of_arguments, ctx=_ast.Load()), ctx=_ast.Load()) expression_node.value = _ast.Call( func=_ast.Attribute(value=_ast.Name(id='self', ctx=_ast.Load()), attr='_assert_mock', ctx=_ast.Load()), args=[ number_of_invocations, target_mock, target_method, spread_list_of_arguments ], keywords=[]) return expression_node
def separate_assing_nodes(self, node: _ast.Assign, variables_names, variables): if isinstance(node.targets[0], _ast.Tuple): tuple_key = meta.values_for_ast_type[type(node.targets[0])] for num, target_node in enumerate( getattr(node.targets[0], tuple_key)): if isinstance(node.value, _ast.Tuple): inner_value = getattr(node.value, tuple_key)[num] else: node_value = self.get_value(node.value, variables_names, variables) if isinstance(node_value, dict): inner_value = _ast.Subscript( value=node.value, slice=_ast.Index(value=_ast.Num(n=num))) else: inner_value = node_value var = _ast.Assign(targets=[target_node], value=inner_value) yield var elif isinstance(node.value, _ast.List): for target in node.targets: for elem in node.value.elts: # for items var = _ast.Assign(targets=[target], value=elem) yield var elif isinstance(node.value, _ast.Call): value = self.get_value(node.value, variables_names, variables) for target in node.targets: # for items in call result var = _ast.Assign(targets=[target], value=value) yield var
def test_issue1673_Num_notfullinit(self): import ast import copy num_node = ast.Num(n=2, lineno=2) assert num_node.n == 2 assert num_node.lineno == 2 num_node2 = copy.deepcopy(num_node)
def visit_str(self, x): if x == '0': return _ast.Num(0) if x == 'False': return kast.false if isinstance(self.current, (ast.Str, ast.Name, ast.FunctionDef, ast.Attribute, ast.alias, ast.keyword)): return x # todo: whitelist!! return ast.Str(x)
def while_loop(self, instr, loop_block): kw = dict(lineno=instr.lineno, col_offset=0) loop_block_map = {instr.i: instr.op for instr in loop_block} first_i = loop_block[0].i func = lambda instr: instr.opname == 'JUMP_ABSOLUTE' and instr.oparg == first_i body_index = rfind_index(loop_block[:-1], func) if body_index is None: const_while = True body_index = len(loop_block) - 1 else: if body_index + 1 < len(loop_block): pop_block = loop_block[body_index + 1] const_while = pop_block.opname != 'POP_BLOCK' const_else = True else: const_while = True const_else = False if const_while: test = _ast.Num(1, **kw) body_ = self.decompile_block(loop_block[:body_index]).stmnt() else_block = loop_block[body_index + 1:] if else_block: else_ = self.decompile_block(else_block).stmnt() else: else_ = [] else: pop_block = loop_block[body_index + 1] func = lambda instr: instr.opname in [ 'POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE' ] and instr.oparg == pop_block.i idx = rfind_index(loop_block[:body_index], func) cond_block = loop_block[:idx] iter_stmnt = self.decompile_block(cond_block).stmnt() assert len(iter_stmnt) == 1 test = iter_stmnt[0] body_ = self.decompile_block(loop_block[idx + 1:body_index]).stmnt() else_block = loop_block[body_index + 2:] if else_block: else_ = self.decompile_block(else_block[:]).stmnt() else: else_ = [] while_ = _ast.While(test=test, body=body_, orelse=else_, **kw) self.ast_stack.append(while_)
def test_issue1673_Num_fullinit(self): import ast import copy num_node = ast.Num(n=2, lineno=2, col_offset=3) num_node2 = copy.deepcopy(num_node) assert num_node.n == num_node2.n assert num_node.lineno == num_node2.lineno assert num_node.col_offset == num_node2.col_offset dict_res = num_node2.__dict__ assert dict_res == {'n': 2, 'lineno': 2, 'col_offset': 3}
def test_compare(self): import ast def _mod(mod, msg=None, mode="exec", exc=ValueError): mod.lineno = mod.col_offset = 0 ast.fix_missing_locations(mod) exc = raises(exc, compile, mod, "<test>", mode) if msg is not None: assert msg in str(exc.value) def _expr(node, msg=None, exc=ValueError): mod = ast.Module([ast.Expr(node)]) _mod(mod, msg, exc=exc) left = ast.Name("x", ast.Load()) comp = ast.Compare(left, [ast.In()], []) _expr(comp, "no comparators") comp = ast.Compare(left, [ast.In()], [ast.Num(4), ast.Num(5)]) _expr(comp, "different number of comparators and operands") comp = ast.Compare(ast.Num("blah"), [ast.In()], [left]) _expr(comp, "non-numeric", exc=TypeError) comp = ast.Compare(left, [ast.In()], [ast.Num("blah")]) _expr(comp, "non-numeric", exc=TypeError)
def visit_For(self, node): #try: if node.iter.func.id != 'range': raise AttributeError() args = node.iter.args lower = args[0] if len( args ) > 1 else _ast.Num(0) upper = args[1] if len( args ) > 1 else args[0] step = args[2] if len( args ) > 2 else _ast.Num(1) i = node.target.id print >> self.o, (self.ident+2)*" " + "for (int {}=".format(i), self.visit( lower ) print >> self.o, "; {}<".format(i), self.visit( upper ) print >> self.o, "; {0}={0}+".format(i), self.visit( step ) print >> self.o, ") { " for x in node.body: self.visit(x) print >> self.o, (self.ident+2)*" " + "}"
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 test_list_syncing(self): ast = self.ast mod = ast.Module([ast.Lt()]) raises(TypeError, compile, mod, "<string>", "exec") mod = self.get_ast("x = y = 3") assign = mod.body[0] assert len(assign.targets) == 2 assign.targets[1] = ast.Name("lemon", ast.Store(), lineno=0, col_offset=0) name = ast.Name("apple", ast.Store(), lineno=0, col_offset=0) mod.body.append(ast.Assign([name], ast.Num(4, lineno=0, col_offset=0), lineno=0, col_offset=0)) co = compile(mod, "<test>", "exec") ns = {} exec co in ns assert "y" not in ns assert ns["x"] == ns["lemon"] == 3 assert ns["apple"] == 4
def test_bug_null_in_objspace_type(self): import ast code = ast.Expression( lineno=1, col_offset=1, body=ast.ListComp( lineno=1, col_offset=1, elt=ast.Call(lineno=1, col_offset=1, func=ast.Name(lineno=1, col_offset=1, id='str', ctx=ast.Load(lineno=1, col_offset=1)), args=[ ast.Name(lineno=1, col_offset=1, id='x', ctx=ast.Load(lineno=1, col_offset=1)) ], keywords=[]), generators=[ ast.comprehension( lineno=1, col_offset=1, target=ast.Name(lineno=1, col_offset=1, id='x', ctx=ast.Store(lineno=1, col_offset=1)), iter=ast.List( lineno=1, col_offset=1, elts=[ast.Num(lineno=1, col_offset=1, n=23)], ctx=ast.Load( lineno=1, col_offset=1, )), ifs=[]) ])) compile(code, '<template>', 'eval')
def parseString(a, v,tag=None): if not v: return None # if(a=='name'):return v # if(isinstance(v,Na) v=v.strip() if(v.isdigit()):v= _ast.Num(int(v)) #todo: float! elif(v.startswith("[") and tag!="Call" and tag!="Assign"): # too much suggar?? args=v[1:-1].replace(","," ").split(" ") v=[] for arg in args: if(arg.isdigit()):v.append(Num(int(arg))) else:v.append(name(id=arg,ctx=Load())) elif(v.startswith("'")): v=Str(v[1:-1]) elif(a!='id'): ctx=Load() if a=='func' or a=='value' or a=='values': ctx=Load() if a=='target': ctx=Store() v=name(id=v,ctx=ctx,tag=tag) return v
def _cfa(body, state, on_gen): assert isinstance(on_gen, list) for c in on_gen: assert callable(c) cfg = state.cfg def make_connect(cur_bid): assert isinstance(cur_bid, int) def inner(new_bid): assert isinstance(new_bid, int) state.connect([cur_bid], [new_bid]) return inner def push_block(block): block_id = len(cfg.blocks) assert block_id not in cfg.blocks cfg.blocks[block_id] = block for c in on_gen: c(block_id) return block_id cur_block = [] for b in body: if REDUCE_FORS_TO_WHILES and isinstance(b, _ast.For): if isinstance(b.iter, _ast.Call) and isinstance( b.iter.func, _ast.Name) and b.iter.func.id in ("range", "xrange"): if not b.iter.keywords and not b.iter.starargs and not b.iter.kwargs: end_var = "__wfend_%d_%d_" % (b.lineno, b.col_offset) iter_var = "__wfiter_%d_%d_" % (b.lineno, b.col_offset) if len(b.iter.args) in (1, 2): if len(b.iter.args) == 1: start = _ast.Num(0) end = b.iter.args[0] elif len(b.iter.args) == 2: start = b.iter.args[0] end = b.iter.args[1] else: start = b.iter.args[0] end = b.iter.args[1] cur_block.append( _ast.Assign([ _ast.Name( iter_var, _ast.Store(), not_real=True) ], start, lineno=b.lineno, col_offset=b.col_offset, not_real=True)) cur_block.append( _ast.Assign([ _ast.Name(end_var, _ast.Store(), not_real=True) ], end, lineno=b.lineno, col_offset=b.col_offset, not_real=True)) body = [ _ast.Assign([b.target], _ast.Name(iter_var, _ast.Load(), not_real=True), lineno=b.lineno, col_offset=b.col_offset, not_real=True), _ast.Assign([ _ast.Name( iter_var, _ast.Store(), not_real=True) ], _ast.BinOp( _ast.Name(iter_var, _ast.Load(), not_real=True), _ast.Add(), _ast.Num(1)), lineno=b.lineno, col_offset=b.col_offset, not_real=True) ] + b.body b = _ast.While(_ast.Compare( _ast.Name(iter_var, _ast.Load(), not_real=True), [_ast.Lt()], [_ast.Name(end_var, _ast.Load(), not_real=True)], lineno=b.lineno, col_offset=b.col_offset, not_real=True), body, b.orelse, not_real=True) if isinstance(b, ( _ast.Assign, _ast.AugAssign, _ast.ClassDef, _ast.Delete, _ast.Exec, _ast.Expr, _ast.FunctionDef, _ast.Global, _ast.Import, _ast.ImportFrom, _ast.Print, _ast.Pass, )): cur_block.append(b) elif isinstance(b, _ast.Assert): cur_block.append(b) if isinstance(b.test, _ast.Call) and isinstance( b.test.func, _ast.Name ) and b.test.func.id == "isinstance" and isinstance( b.test.args[0], _ast.Name) and isinstance( b.test.args[1], _ast.Name): varname = b.test.args[0].id cast = _ast.Call(_ast.Name( "__cast__", _ast.Load(), not_real=True, **pos(b)), [ _ast.Name( varname, _ast.Store(), not_real=True, **pos(b)), b.test.args[1] ], [], None, None, not_real=True, **pos(b)) assign = _ast.Assign([ _ast.Name(varname, _ast.Store(), not_real=True, **pos(b)) ], cast, not_real=True, lineno=b.lineno, col_offset=b.col_offset) cur_block.append(assign) elif isinstance(b, (_ast.Break, _ast.Continue)): f = state.add_break if isinstance( b, _ast.Break) else state.add_continue if cur_block: j = Jump() cur_block.append(j) block_id = push_block(cur_block) f(j.set_dest) f(make_connect(block_id)) else: for c in on_gen: f(c) return [] elif isinstance(b, _ast.If): br = Branch(b.test, lineno=b.lineno) cur_block.append(br) next_block = push_block(cur_block) on_gen = None # make sure this doesn't get used cur_block = [] gen_true = [br.set_true, make_connect(next_block)] gen_false = [br.set_false, make_connect(next_block)] if ENFORCE_NO_MULTIMULTI: on_gen = gen_true j1 = Jump() gen_true = [make_connect(push_block([j1])), j1.set_dest] on_gen = gen_false j2 = Jump() gen_false = [make_connect(push_block([j2])), j2.set_dest] on_gen = None assert b.body body = b.body if isinstance(b.test, _ast.Call) and isinstance( b.test.func, _ast.Name ) and b.test.func.id == "isinstance" and isinstance( b.test.args[0], _ast.Name) and isinstance( b.test.args[1], _ast.Name): varname = b.test.args[0].id cast = _ast.Call(_ast.Name( "__cast__", _ast.Load(), not_real=True, **pos(b)), [ _ast.Name( varname, _ast.Store(), not_real=True, **pos(b)), b.test.args[1] ], [], None, None, not_real=True, **pos(b)) assign = _ast.Assign([ _ast.Name(varname, _ast.Store(), not_real=True, **pos(b)) ], cast, not_real=True, lineno=b.lineno, col_offset=b.col_offset) body = [assign] + body if ADD_IF_ASSERTS: body = [_ast.Assert(b.test, None, not_real=True, **pos(b)) ] + body ending_gen = _cfa(body, state, gen_true) if b.orelse: ending_gen += _cfa(b.orelse, state, gen_false) else: ending_gen += gen_false on_gen = ending_gen if not on_gen and PRUNE_UNREACHABLE_BLOCKS: return [] elif isinstance(b, _ast.TryExcept): j = Jump() cur_block.append(j) next_block = push_block(cur_block) on_gen = [j.set_dest, make_connect(next_block)] cur_block = [] on_gen = _cfa(b.body, state, on_gen) # Set this to evaluate a string to try to defeat simple flow analysis br = Branch(_ast.Str("nonzero")) next_block = push_block([br]) on_except = [br.set_false, make_connect(next_block)] on_fine = [br.set_true, make_connect(next_block)] assert len(b.handlers) >= 1 # for handler in b.handlers: # on_except = _cfa(b.handlers[0].body, state, on_except) if b.orelse: on_fine = _cfa(b.orelse, state, on_fine) if ENFORCE_NO_MULTIMULTI: j = Jump() on_gen = on_fine next_block = push_block([j]) on_fine = [j.set_dest, make_connect(next_block)] j = Jump() on_gen = on_except next_block = push_block([j]) on_except = [j.set_dest, make_connect(next_block)] on_gen = on_fine + on_except cur_block = [] elif isinstance(b, _ast.TryFinally): j = Jump() cur_block.append(j) next_block = push_block(cur_block) on_gen = [j.set_dest, make_connect(next_block)] cur_block = [] on_gen = _cfa(b.body, state, on_gen) on_gen = _cfa(b.finalbody, state, on_gen) elif isinstance(b, _ast.While): # This could also be architected as having no extra block and having two jump statements, but I don't like that if cur_block: j = Jump() cur_block.append(j) on_gen = [make_connect(push_block(cur_block)), j.set_dest] cur_block = [] always_true = False always_false = False if isinstance(b.test, _ast.Name): if b.test.id == "True": always_true = True elif b.test.id == "False": always_false = True elif isinstance(b.test, _ast.Num): if b.test.n: always_true = True else: always_false = True if always_true: br = Jump() on_true = br.set_dest elif always_false: br = Jump() on_false = br.set_dest else: br = Branch(b.test) on_true = br.set_true on_false = br.set_false init_id = push_block([br]) on_gen = None assert cur_block == [] # just checking if not always_false: gen_true = [on_true, make_connect(init_id)] if not always_true: gen_false = [on_false, make_connect(init_id)] if ENFORCE_NO_MULTIMULTI: if not always_false: on_gen = gen_true j1 = Jump() gen_true = [make_connect(push_block([j1])), j1.set_dest] if not always_true: on_gen = gen_false j2 = Jump() gen_false = [make_connect(push_block([j2])), j2.set_dest] on_gen = None ending_gen = [] if not always_false: state.push_loop() assert b.body loop_ending_gen = _cfa(b.body, state, gen_true) loop_ending_gen += state.get_continues() for c in loop_ending_gen: c(init_id) ending_gen = state.get_breaks() state.pop_loop() if not always_true: if b.orelse: ending_gen += _cfa(b.orelse, state, gen_false) else: ending_gen += gen_false on_gen = ending_gen if not on_gen and PRUNE_UNREACHABLE_BLOCKS: return [] elif isinstance(b, _ast.For): iter_func = _ast.Attribute(b.iter, "__iter__", _ast.Load(), not_real=True, lineno=b.lineno, col_offset=b.col_offset) iter_call = _ast.Call(iter_func, [], [], None, None, not_real=True, lineno=b.lineno, col_offset=b.col_offset) # iter_var = _make_temp_name() iter_var = "__foriter_%d_%d_" % (b.lineno, b.col_offset) iter_assign = _ast.Assign( [_ast.Name(iter_var, _ast.Store(), not_real=True, **pos(b))], iter_call, not_real=True, lineno=b.lineno, col_offset=b.col_offset) cur_block.append(iter_assign) j = Jump() cur_block.append(j) on_gen = [make_connect(push_block(cur_block)), j.set_dest] cur_block = [] br = Branch( HasNext( _ast.Name(iter_var, _ast.Load(), not_real=True, **pos(b)), **pos(b)), **pos(b)) init_id = push_block([br]) on_gen = None assert cur_block == [] # just checking gen_true = [br.set_true, make_connect(init_id)] gen_false = [br.set_false, make_connect(init_id)] if ENFORCE_NO_MULTIMULTI: on_gen = gen_true j1 = Jump() gen_true = [make_connect(push_block([j1])), j1.set_dest] on_gen = gen_false j2 = Jump() gen_false = [make_connect(push_block([j2])), j2.set_dest] on_gen = None ending_gen = [] state.push_loop() next_func = _ast.Attribute(_ast.Name(iter_var, _ast.Load(), not_real=True, **pos(b)), "next", _ast.Load(), not_real=True, lineno=b.lineno, col_offset=b.col_offset) next = _ast.Call(next_func, [], [], None, None, not_real=True, lineno=b.lineno, col_offset=b.col_offset) next_assign = _ast.Assign([b.target], next, not_real=True, lineno=b.lineno, col_offset=b.col_offset) next_iter_gen = _cfa([next_assign] + b.body, state, gen_true) next_iter_gen += state.get_continues() for c in next_iter_gen: c(init_id) loop_done_gen = list(state.get_breaks()) state.pop_loop() if b.orelse: # if b.orelse and loop_ending_blocks: loop_done_gen += _cfa(b.orelse, state, gen_false) else: loop_done_gen += gen_false on_gen = loop_done_gen if not on_gen and PRUNE_UNREACHABLE_BLOCKS: return [] elif isinstance(b, (_ast.Return, _ast.Raise)): cur_block.append(b) block_id = push_block(cur_block) state.returns.append(make_connect(block_id)) return [] elif isinstance(b, _ast.With): # XXX totally ignores the functionality of with statements # Have to save the context manager because the expression might not be valid later mgr_name = "__mgr_%s_%s_" % (b.lineno, b.col_offset) save_mgr = _ast.Assign([ _ast.Name(mgr_name, _ast.Store(), lineno=b.lineno, col_offset=b.col_offset, not_real=True) ], b.context_expr, lineno=b.lineno, col_offset=b.col_offset, not_real=True) enter_func = _ast.Attribute(_ast.Name(mgr_name, _ast.Load(), lineno=b.lineno, col_offset=b.col_offset, not_real=True), "__enter__", _ast.Load(), lineno=b.lineno, col_offset=b.col_offset, not_real=True) bind = _ast.Call(enter_func, [], [], None, None, lineno=b.lineno, col_offset="__enter__()", not_real=True) if b.optional_vars: assert isinstance(b.optional_vars, _ast.AST) init = _ast.Assign([b.optional_vars], bind, lineno=b.lineno, col_offset=b.col_offset, not_real=True) else: init = _ast.Expr(bind, lineno=b.lineno, col_offset=b.col_offset, not_real=True) exit_func = _ast.Attribute(_ast.Name(mgr_name, _ast.Load(), lineno=b.lineno, col_offset=b.col_offset, not_real=True), "__exit__", _ast.Load(), lineno=b.lineno, col_offset=b.col_offset, not_real=True) if SIMPLE_WITH_EXIT: exit_call = _ast.Call(exit_func, [], [], None, None, lineno=b.lineno, col_offset=b.col_offset, not_real=True) else: none_ = _ast.Name("None", _ast.Load(), lineno=b.lineno, col_offset=b.col_offset, not_real=True) exit_call = _ast.Call(exit_func, [none_, none_, none_], [], None, None, lineno=b.lineno, col_offset=b.col_offset, not_real=True) exit = _ast.Expr(exit_call, lineno=b.lineno, col_offset="__exit__()", not_real=True) cur_block.extend([save_mgr, init]) j = Jump() cur_block.append(j) next_block = push_block(cur_block) on_gen = [j.set_dest, make_connect(next_block)] cur_block = [] body = b.body + [exit] next_gen = _cfa(body, state, on_gen) on_gen = next_gen else: raise Exception(b) if cur_block: j = Jump() cur_block.append(j) next = push_block(cur_block) return [j.set_dest, make_connect(next)] return on_gen return on_gen
def visit_Name( self, node ): if node.id in self.captured_vars: return _ast.Num( n=self.captured_vars[ node.id ] ) else: return node
def Num(number): """Creates an _ast.Num node.""" return _ast.Num(number)
def test_dict_astNode(self): import ast num_node = ast.Num(n=2, lineno=2, col_offset=3) dict_res = num_node.__dict__ assert dict_res == {'n': 2, 'lineno': 2, 'col_offset': 3}
def visit_Num(self, node): if self.randomize(): number = random.random() * node.n return ast.copy_location(_ast.Num(n=number), node) else: return node
def test_field_attr_writable(self): import _ast as ast x = ast.Num() # We can assign to _fields x._fields = 666 assert x._fields == 666
def num(n=None): return _ast.Num(n=n)
def test_return_value_is_int_zero(): # when method return 0 assert ReturnedExpression(_ast.Return(value=_ast.Num(n=0), lineno=1)).value_not_none() is True
def test_return_value_is_float_limit_to_zero(): # when method return 0.0000000000000000000000001 assert ReturnedExpression( _ast.Return(value=_ast.Num(n=0.0000000000000000000000001), lineno=1), ).value_not_none() is True