Author: Brian Kearns <bdkea...@gmail.com>
Branch: 
Changeset: r70034:8475b0021a83
Date: 2014-03-17 18:07 -0400
http://bitbucket.org/pypy/pypy/changeset/8475b0021a83/

Log:    cleanup

diff --git a/rpython/jit/metainterp/test/test_virtual.py 
b/rpython/jit/metainterp/test/test_virtual.py
--- a/rpython/jit/metainterp/test/test_virtual.py
+++ b/rpython/jit/metainterp/test/test_virtual.py
@@ -7,12 +7,13 @@
 from rpython.rtyper.lltypesystem.lloperation import llop
 from rpython.jit.codewriter import heaptracker
 
+
 class VirtualTests:
     def _freeze_(self):
         return True
 
     def test_virtualized1(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = self._new()
             node.value = 0
@@ -33,9 +34,8 @@
         self.check_resops(new_with_vtable=0, setfield_gc=0,
                           getfield_gc=2, new=0)
 
-
     def test_virtualized2(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node1', 'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node1', 'node2'])
         def f(n):
             node1 = self._new()
             node1.value = 0
@@ -59,7 +59,7 @@
     def test_virtualized_circular1(self):
         class MyNode():
             pass
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = MyNode()
             node.value = 0
@@ -79,11 +79,11 @@
         res = self.meta_interp(f, [10])
         assert res == 55 * 10
         self.check_trace_count(1)
-        self.check_resops(new_with_vtable=0, setfield_gc=0,
-                          getfield_gc=3, new=0)
+        self.check_resops(new_with_vtable=0, setfield_gc=0, getfield_gc=3,
+                          new=0)
 
     def test_virtualized_float(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = self._new()
             node.floatval = 0.0
@@ -100,7 +100,7 @@
         self.check_resops(new=0, float_add=1)
 
     def test_virtualized_float2(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = self._new()
             node.floatval = 0.0
@@ -117,9 +117,8 @@
         self.check_trace_count(1)
         self.check_resops(new=0, float_add=2)
 
-
     def test_virtualized_2(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = self._new()
             node.value = 0
@@ -144,7 +143,7 @@
                           new=0)
 
     def test_nonvirtual_obj_delays_loop(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         node0 = self._new()
         node0.value = 10
         def f(n):
@@ -161,11 +160,11 @@
         res = self.meta_interp(f, [500])
         assert res == 640
         self.check_trace_count(1)
-        self.check_resops(new_with_vtable=0, setfield_gc=0,
-                          getfield_gc=1, new=0)
+        self.check_resops(new_with_vtable=0, setfield_gc=0, getfield_gc=1,
+                          new=0)
 
     def test_two_loops_with_virtual(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = self._new()
             node.value = 0
@@ -185,12 +184,11 @@
         res = self.meta_interp(f, [18])
         assert res == f(18)
         self.check_trace_count(2)
-        self.check_resops(new_with_vtable=0, setfield_gc=0,
-                          getfield_gc=2, new=0)
-
+        self.check_resops(new_with_vtable=0, setfield_gc=0, getfield_gc=2,
+                          new=0)
 
     def test_two_loops_with_escaping_virtual(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def externfn(node):
             llop.debug_print(lltype.Void, compute_unique_id(node),
                              node.value, node.extra)
@@ -218,7 +216,7 @@
         self.check_resops(int_mul=0, call=1)
 
     def test_two_virtuals(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'prev'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'prev'])
         class Foo(object):
             def __init__(self, x, y):
                 self.x = x
@@ -241,7 +239,7 @@
         self.check_resops(new_with_vtable=0, new=0)
 
     def test_specialied_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['y', 'x', 'res'])
+        myjitdriver = JitDriver(greens=[], reds=['y', 'x', 'res'])
         class A:
             def __init__(self, val):
                 self.val = val
@@ -253,7 +251,7 @@
                 myjitdriver.can_enter_jit(y=y, x=x, res=res)
                 myjitdriver.jit_merge_point(y=y, x=x, res=res)
                 res = res.binop(A(y))
-                if y<7:
+                if y < 7:
                     res = x
                     x = A(1)
                 y -= 1
@@ -267,7 +265,7 @@
         assert res == g(6, 14)
 
     def test_both_virtual_and_field_variable(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n'])
+        myjitdriver = JitDriver(greens=[], reds=['n'])
         class Foo(object):
             pass
         def f(n):
@@ -286,7 +284,7 @@
         self.check_resops(new_with_vtable=0, new=0)
 
     def test_immutable_constant_getfield(self):
-        myjitdriver = JitDriver(greens = ['stufflist'], reds = ['n', 'i'])
+        myjitdriver = JitDriver(greens=['stufflist'], reds=['n', 'i'])
 
         class Stuff(object):
             _immutable_ = True
@@ -312,7 +310,7 @@
         self.check_resops(getfield_gc=0)
 
     def test_escapes(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'parent'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'parent'])
 
         class Parent(object):
             def __init__(self, node):
@@ -341,7 +339,7 @@
         self.check_resops(**{self._new_op: 1})
 
     def test_virtual_on_virtual(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'parent'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'parent'])
 
         class Node(object):
             def __init__(self, f):
@@ -371,7 +369,7 @@
         self.check_resops(new=0, new_with_vtable=0)
 
     def test_bridge_from_interpreter(self):
-        mydriver = JitDriver(reds = ['n', 'f'], greens = [])
+        mydriver = JitDriver(reds=['n', 'f'], greens=[])
 
         def f(n):
             f = self._new()
@@ -397,7 +395,7 @@
         self.check_enter_count(2)
 
     def test_new_virtual_member_in_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'sa', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'sa', 'node'])
         def f(n):
             node = self._new()
             node.value = 1
@@ -406,19 +404,19 @@
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, sa=sa, node=node)
                 myjitdriver.jit_merge_point(n=n, sa=sa, node=node)
-                if n&30 > 0:
+                if n & 30 > 0:
                     sa += node.value
                     next = self._new()
                     next.value = n
                     node = next
-                    if n<10:
+                    if n < 10:
                         node.extra = sa
                 n -= 1
             return node.extra
         assert self.meta_interp(f, [20]) == f(20)
 
     def test_constant_virtual1(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'sa', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'sa', 'node'])
         def f(n):
             node = self._new()
             node.value = 1
@@ -426,11 +424,11 @@
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, sa=sa, node=node)
                 myjitdriver.jit_merge_point(n=n, sa=sa, node=node)
-                if n>20:
+                if n > 20:
                     next = self._new()
                     next.value = 2
                     node = next
-                elif n>10:
+                elif n > 10:
                     next = self._new()
                     next.value = 3
                     node = next
@@ -440,7 +438,7 @@
         assert self.meta_interp(f, [30]) == f(30)
 
     def test_constant_virtual2(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'sa', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'sa', 'node'])
         def f(n):
             node = self._new()
             node.value = 1
@@ -449,7 +447,7 @@
                 myjitdriver.can_enter_jit(n=n, sa=sa, node=node)
                 myjitdriver.jit_merge_point(n=n, sa=sa, node=node)
                 sa += node.value
-                if n&15 > 7:
+                if n & 15 > 7:
                     next = self._new()
                     next.value = 2
                     node = next
@@ -465,7 +463,7 @@
         class RefNode(object):
             def __init__(self, ref):
                 self.ref = ref
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'sa', 'node1', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'sa', 'node1', 'node2'])
         def f(n):
             node1 = self._new()
             node1.value = 1
@@ -474,7 +472,7 @@
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, sa=sa, node1=node1, node2=node2)
                 myjitdriver.jit_merge_point(n=n, sa=sa, node1=node1, 
node2=node2)
-                if n>10:
+                if n > 10:
                     next = self._new()
                     next.value = 2
                     node1 = next
@@ -496,7 +494,7 @@
         class RefNode(object):
             def __init__(self, ref):
                 self.ref = ref
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'sa', 'node1', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'sa', 'node1', 'node2'])
         def f(n):
             node1 = self._new()
             node1.value = 1
@@ -505,7 +503,7 @@
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, sa=sa, node1=node1, node2=node2)
                 myjitdriver.jit_merge_point(n=n, sa=sa, node1=node1, 
node2=node2)
-                if n>10:
+                if n > 10:
                     next = self._new()
                     next.value = node1.value + 2
                     node1 = next
@@ -522,7 +520,7 @@
         class RefNode(object):
             def __init__(self, ref):
                 self.ref = ref
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'sa', 'node1', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'sa', 'node1', 'node2'])
         def f(n):
             node1 = self._new()
             node1.value = 1
@@ -533,7 +531,7 @@
                 myjitdriver.jit_merge_point(n=n, sa=sa, node1=node1, 
node2=node2)
                 node2.ref.value += n
                 sa += node1.value
-                if n>10:
+                if n > 10:
                     next = self._new()
                     next.value = node1.value + 1
                     node1 = next
@@ -544,7 +542,7 @@
         assert self.meta_interp(f, [20]) == f(20)
 
     def test_dual_counter(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 's', 'node1', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 's', 'node1', 'node2'])
         def f(n, s):
             node1 = self._new()
             node1.value = 1
@@ -553,7 +551,7 @@
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, s=s, node1=node1, node2=node2)
                 myjitdriver.jit_merge_point(n=n, s=s, node1=node1, node2=node2)
-                if (n>>s) & 1:
+                if (n >> s) & 1:
                     next = self._new()
                     next.value = node1.value + 1
                     node1 = next
@@ -570,7 +568,7 @@
         self.check_resops(new=0, new_with_vtable=0)
 
     def test_single_virtual_forced_in_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 's', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 's', 'node'])
         def externfn(node):
             node.value *= 2
         def f(n, s):
@@ -582,7 +580,7 @@
                 next = self._new()
                 next.value = node.value + 1
                 node = next
-                if (n>>s) & 1:
+                if (n >> s) & 1:
                     externfn(node)
                 n -= 1
             return node.value
@@ -592,7 +590,7 @@
         assert res == f(40, 3)
 
     def test_forced_virtual_assigned_in_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 's', 'node', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 's', 'node', 'node2'])
         def externfn(node):
             node.value += 1
         def f(n, s):
@@ -606,7 +604,7 @@
                 next = self._new()
                 next.value = node.value + 1
                 node = next
-                if (n>>s) & 1:
+                if (n >> s) & 1:
                     node2.value += node.value
                     node = node2
                 externfn(node)
@@ -620,7 +618,7 @@
         self.check_trace_count(3)
 
     def test_forced_virtual_assigned_different_class_in_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 's', 'node', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 's', 'node', 'node2'])
         def externfn(node):
             node.value += 1
         class A(object):
@@ -636,7 +634,7 @@
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, s=s, node=node, node2=node2)
                 myjitdriver.jit_merge_point(n=n, s=s, node=node, node2=node2)
-                if (n>>s) & 1:
+                if (n >> s) & 1:
                     node2.value += node.value
                     node = node2
                 else:
@@ -659,7 +657,7 @@
         assert res == g2(48, 3)
 
     def test_empty_virtual_with_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 's', 'sa', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 's', 'sa', 'node'])
         def f(n, s):
             node = self._new()
             sa = 0
@@ -668,7 +666,7 @@
                 myjitdriver.jit_merge_point(n=n, s=s, sa=sa, node=node)
                 next = self._new()
                 node = next
-                if (n>>s) & 1:
+                if (n >> s) & 1:
                     sa += 1
                 else:
                     sa += 2
@@ -680,13 +678,13 @@
         assert res == f(40, 3)
 
     def test_virtual_array_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = [42, 42]
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, node=node)
                 myjitdriver.jit_merge_point(n=n, node=node)
-                if (n>>3) & 1:
+                if (n >> 3) & 1:
                     node = [node[0], node[1] + n]
                 else:
                     node = [node[0] + n, node[1]]
@@ -695,13 +693,13 @@
         assert self.meta_interp(f, [40]) == f(40)
 
     def test_virtual_array_different_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node'])
         def f(n):
             node = [42, 42]
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, node=node)
                 myjitdriver.jit_merge_point(n=n, node=node)
-                if (n>>3) & 1:
+                if (n >> 3) & 1:
                     node = [node[0], node[1] + n]
                 else:
                     node = [node[0] + n, node[-1], node[0] + node[1]]
@@ -710,7 +708,7 @@
         assert self.meta_interp(f, [40]) == f(40)
 
     def FIXME_why_does_this_force(self):
-        mydriver = JitDriver(reds = ['i', 'j'], greens = [])
+        mydriver = JitDriver(reds=['i', 'j'], greens=[])
         def f():
             i = self._new()
             i.value = 0
@@ -726,7 +724,7 @@
         assert self.meta_interp(f, []) == 20
 
     def FIXME_why_does_this_force2(self):
-        mydriver = JitDriver(reds = ['i', 'j'], greens = [])
+        mydriver = JitDriver(reds=['i', 'j'], greens=[])
         def f():
             i = self._new()
             i.value = 0
@@ -746,7 +744,7 @@
         assert self.meta_interp(f, []) == 20
 
     def test_virtual_skipped_by_bridge(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'm', 'i', 'x'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'm', 'i', 'x'])
         def f(n, m):
             x = self._new()
             x.value = 0
@@ -754,7 +752,7 @@
             while i < n:
                 myjitdriver.can_enter_jit(n=n, m=m, i=i, x=x)
                 myjitdriver.jit_merge_point(n=n, m=m, i=i, x=x)
-                if i&m != m:
+                if i & m != m:
                     newx = self._new()
                     newx.value = x.value + i
                     x = newx
@@ -764,7 +762,7 @@
         assert res == f(0x1F, 0x11)
 
     def test_duplicated_virtual(self):
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'node1', 'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'node1', 'node2'])
         def f(n):
             node1 = self._new()
             node1.value = 0
@@ -782,13 +780,11 @@
         assert res == f(10)
         self.check_resops(new_with_vtable=0, new=0)
 
-
-
     def test_retrace_not_matching_bridge(self):
         @dont_look_inside
         def external(node):
             return node.value + 1
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'i', 'node', 
'node2'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'i', 'node', 'node2'])
         class A():
             def new(self):
                 return A()
@@ -825,7 +821,7 @@
         @dont_look_inside
         def external(node):
             return node.value + 1
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'i', 'node', 
'node2', 's'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'i', 'node', 'node2', 
's'])
         class A():
             def new(self):
                 return A()
@@ -866,7 +862,7 @@
         bytecode = "iajb+JI"
         def get_printable_location(i):
             return "%d: %s" % (i, bytecode[i])
-        myjitdriver = JitDriver(greens = ['pc'], reds = ['n', 'sa', 'i', 'j'],
+        myjitdriver = JitDriver(greens=['pc'], reds=['n', 'sa', 'i', 'j'],
                                 get_printable_location=get_printable_location)
         def f(n):
             pc = sa = 0
@@ -907,7 +903,7 @@
         class Int(object):
             def __init__(self, val):
                 self.val = val
-        myjitdriver = JitDriver(greens = ['pc'], reds = ['n', 'sa', 'i', 'j'])
+        myjitdriver = JitDriver(greens=['pc'], reds=['n', 'sa', 'i', 'j'])
         bytecode = "iajb+JI"
         def f(n):
             pc = sa = 0
@@ -947,10 +943,10 @@
         self.check_aborted_count(0)
         self.check_target_token_count(3)
 
+
 class VirtualMiscTests:
-
     def test_multiple_equal_virtuals(self):
-        mydriver = JitDriver(reds = ['i'], greens = [])
+        mydriver = JitDriver(reds=['i'], greens=[])
         class A:
             pass
         def f():
@@ -971,7 +967,7 @@
         class A(object):
             def __init__(self, x):
                 self.x = x
-        mydriver = JitDriver(reds = ['n'], greens = [])
+        mydriver = JitDriver(reds=['n'], greens=[])
         global_a = A(0)
 
         def g(a):
@@ -996,7 +992,7 @@
         class A(object):
             def __init__(self, x):
                 self.x = x
-        mydriver = JitDriver(reds = ['n', 'tot'], greens = [])
+        mydriver = JitDriver(reds=['n', 'tot'], greens=[])
 
         def f(n):
             tot = 0
@@ -1017,7 +1013,7 @@
         assert r == expected
 
     def test_arraycopy_disappears(self):
-        mydriver = JitDriver(reds = ['i'], greens = [])
+        mydriver = JitDriver(reds=['i'], greens=[])
         def f():
             i = 0
             while i < 10:
@@ -1033,7 +1029,7 @@
         self.check_resops(new_array=0)
 
     def test_virtual_streq_bug(self):
-        mydriver = JitDriver(reds = ['i', 's', 'a'], greens = [])
+        mydriver = JitDriver(reds=['i', 's', 'a'], greens=[])
 
         class A(object):
             def __init__(self, state):
@@ -1060,7 +1056,7 @@
         assert res == f()
 
     def test_getfield_gc_pure_nobug(self):
-        mydriver = JitDriver(reds = ['i', 's', 'a'], greens = [])
+        mydriver = JitDriver(reds=['i', 's', 'a'], greens=[])
 
         class A(object):
             _immutable_fields_ = ['foo']
@@ -1088,7 +1084,7 @@
         assert res == f()
 
     def test_virtual_attribute_pure_function(self):
-        mydriver = JitDriver(reds = ['i', 'sa', 'n', 'node'], greens = [])
+        mydriver = JitDriver(reds=['i', 'sa', 'n', 'node'], greens=[])
         class A(object):
             def __init__(self, v1, v2):
                 self.v1 = v1
@@ -1110,7 +1106,7 @@
         assert res == f(16)
 
     def test_virtual_loop_invariant_getitem(self):
-        mydriver = JitDriver(reds = ['i', 'sa', 'n', 'node1', 'node2'], greens 
= [])
+        mydriver = JitDriver(reds=['i', 'sa', 'n', 'node1', 'node2'], 
greens=[])
         class A(object):
             def __init__(self, v1, v2):
                 self.v1 = v1
@@ -1134,7 +1130,7 @@
         self.check_resops(getfield_gc=7)
 
     def test_raw_malloc(self):
-        mydriver = JitDriver(greens=[], reds = 'auto')
+        mydriver = JitDriver(greens=[], reds='auto')
         def f(n):
             i = 0
             res = 0
@@ -1153,7 +1149,7 @@
         self.check_resops({'guard_true': 2, 'int_add': 4, 'int_lt': 2, 'jump': 
1})
 
     def test_raw_malloc_resume(self):
-        mydriver = JitDriver(greens=[], reds = 'auto')
+        mydriver = JitDriver(greens=[], reds='auto')
         def f(n):
             i = 0
             res = 0
@@ -1177,7 +1173,7 @@
                            'jump': 2})
 
     def test_raw_malloc_no_virtualstate(self):
-        mydriver = JitDriver(greens=[], reds = 'auto')
+        mydriver = JitDriver(greens=[], reds='auto')
         def f(n):
             res = 0
             buffer = lltype.malloc(rffi.CCHARP.TO, 1, flavor='raw')
@@ -1199,7 +1195,7 @@
         self.check_resops(getarrayitem_raw=2, raw_store=2)
 
     def test_raw_malloc_only_chars(self):
-        mydriver = JitDriver(greens=[], reds = 'auto')
+        mydriver = JitDriver(greens=[], reds='auto')
         def f(n):
             i = 0
             res = 0
@@ -1218,7 +1214,6 @@
         self.check_trace_count(1)
         self.check_resops(setarrayitem_raw=2, getarrayitem_raw=4)
 
-
 # ____________________________________________________________
 # Run 1: all the tests instantiate a real RPython class
 
@@ -1241,12 +1236,12 @@
         class Subclass(MyClass):
             pass
 
-        myjitdriver = JitDriver(greens = [], reds = ['n', 'res'])
+        myjitdriver = JitDriver(greens=[], reds=['n', 'res'])
         def f(n):
             res = 0
             node = MyClass()
-            node.value = n  # so that the annotator doesn't think that value 
is constant
-            node.value2 = n # ditto
+            node.value = n   # so that the annotator doesn't think that value 
is constant
+            node.value2 = n  # ditto
             while n > 0:
                 myjitdriver.can_enter_jit(n=n, res=res)
                 myjitdriver.jit_merge_point(n=n, res=res)
@@ -1277,7 +1272,6 @@
     def _new():
         return lltype.malloc(NODE)
 
-
 # ____________________________________________________________
 # Run 3: all the tests use lltype.malloc to make a NODE2
 # (same as Run 2 but it is part of the OBJECT hierarchy)
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit

Reply via email to