http://bugs.python.org/issue2459 -- speed up loops

Lib/test/test_dis.py

 # Minimal tests for dis module
 
 from test.test_support import run_unittest
 import unittest
 import sys
 import dis
 import StringIO
 
 
 def _f(a):
     print a
     return 1
 
 dis_f = """\
  %-4d         0 LOAD_FAST                0 (a)
               3 PRINT_ITEM
               4 PRINT_NEWLINE
 
  %-4d         5 LOAD_CONST               1 (1)
               8 RETURN_VALUE
 """%(_f.func_code.co_firstlineno + 1,
      _f.func_code.co_firstlineno + 2)
 
+
+def loop(a):
+    while a > 0:
+        a -= 1
+    return a
+
+dis_loop = """\
+%3d           0 SETUP_LOOP              26 (to 29)
+              3 JUMP_FORWARD            10 (to 16)
+
+%3d     >>    6 LOAD_FAST                0 (a)
+              9 LOAD_CONST               1 (1)
+             12 INPLACE_SUBTRACT
+             13 STORE_FAST               0 (a)
+
+%3d     >>   16 LOAD_FAST                0 (a)
+             19 LOAD_CONST               2 (0)
+             22 COMPARE_OP               4 (>)
+             25 POP_JUMP_IF_TRUE         6
+             28 POP_BLOCK
+
+%3d     >>   29 LOAD_FAST                0 (a)
+             32 RETURN_VALUE
+"""%(loop.func_code.co_firstlineno + 1,
+     loop.func_code.co_firstlineno + 2,
+     loop.func_code.co_firstlineno + 1,
+     loop.func_code.co_firstlineno + 3)
 
 def bug708901():
     for res in range(1,
                      10):
         pass
 
 dis_bug708901 = """\
  %-4d         0 SETUP_LOOP              23 (to 26)
               3 LOAD_GLOBAL              0 (range)
               6 LOAD_CONST               1 (1)
 
  %-4d         9 LOAD_CONST               2 (10)
              12 CALL_FUNCTION            2
              15 GET_ITER
-        >>   16 FOR_ITER                 6 (to 25)
-             19 STORE_FAST               0 (res)
-
- %-4d        22 JUMP_ABSOLUTE           16
-        >>   25 POP_BLOCK
+             16 JUMP_FORWARD             3 (to 22)
+        >>   19 STORE_FAST               0 (res)
+        >>   22 FOR_ITER                19
+             25 POP_BLOCK
         >>   26 LOAD_CONST               0 (None)
              29 RETURN_VALUE
 """%(bug708901.func_code.co_firstlineno + 1,
-     bug708901.func_code.co_firstlineno + 2,
-     bug708901.func_code.co_firstlineno + 3)
+     bug708901.func_code.co_firstlineno + 2)
 
 
 def bug1333982(x=[]):
     assert 0, ([s for s in x] +
               1)
     pass
 
 dis_bug1333982 = """\
  %-4d         0 LOAD_CONST               1 (0)
               3 POP_JUMP_IF_TRUE        38
               6 LOAD_GLOBAL              0 (AssertionError)
               9 BUILD_LIST               0
              12 LOAD_FAST                0 (x)
              15 GET_ITER
-        >>   16 FOR_ITER                12 (to 31)
-             19 STORE_FAST               1 (s)
+             16 JUMP_FORWARD             9 (to 28)
+        >>   19 STORE_FAST               1 (s)
              22 LOAD_FAST                1 (s)
              25 LIST_APPEND              2
-             28 JUMP_ABSOLUTE           16
+        >>   28 FOR_ITER                19
 
- %-4d   >>   31 LOAD_CONST               2 (1)
+ %-4d        31 LOAD_CONST               2 (1)
              34 BINARY_ADD
              35 RAISE_VARARGS            2
 
  %-4d   >>   38 LOAD_CONST               0 (None)
              41 RETURN_VALUE
 """%(bug1333982.func_code.co_firstlineno + 1,
      bug1333982.func_code.co_firstlineno + 2,
      bug1333982.func_code.co_firstlineno + 3)
 
 _BIG_LINENO_FORMAT = """\
@@ skipping 29 matching lines @@
 
     def test_opname(self):
         self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
 
     def test_boundaries(self):
         self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
         self.assertEqual(dis.opmap["STORE_NAME"], dis.HAVE_ARGUMENT)
 
     def test_dis(self):
         self.do_disassembly_test(_f, dis_f)
+
+    def test_lineno_goes_backwards_in_loop(self):
+        self.do_disassembly_test(loop, dis_loop)
 
     def test_bug_708901(self):
         self.do_disassembly_test(bug708901, dis_bug708901)
 
     def test_bug_1333982(self):
         # This one is checking bytecodes generated for an `assert` statement,
         # so fails if the tests are run with -O.  Skip this test then.
         if __debug__:
             self.do_disassembly_test(bug1333982, dis_bug1333982)
 
@@ skipping 13 matching lines @@
         for i in xrange(300, 5000, 10):
             expected = _BIG_LINENO_FORMAT % (i + 2)
             self.do_disassembly_test(func(i), expected)
 
 def test_main():
     run_unittest(DisTests)
 
 
 if __name__ == "__main__":
     test_main()