Merge branch 'topic/default/modernize' into 'branch/default'

Modernise syntax

See merge request pypy/pypy!718

Author: rlamy

rpython/annotator/binaryop.py

@@ -166,8 +166,8 @@ def union((s_obj1, s_obj2)):
 
 # cloning a function with identical code, for the can_only_throw attribute
 def _clone(f, can_only_throw = None):
-    newfunc = type(f)(f.func_code, f.func_globals, f.func_name,
-                      f.func_defaults, f.func_closure)
+    newfunc = type(f)(f.__code__, f.__globals__, f.__name__,
+                      f.__defaults__, f.__closure__)
     if can_only_throw is not None:
         newfunc.can_only_throw = can_only_throw
     return newfunc

rpython/annotator/bookkeeper.py

@@ -415,8 +415,8 @@ def newfuncdesc(self, pyfunc):
             signature = Signature(['entry'])     # haaaaaack
             defaults = ()
         else:
-            signature = cpython_code_signature(pyfunc.func_code)
-            defaults = pyfunc.func_defaults
+            signature = cpython_code_signature(pyfunc.__code__)
+            defaults = pyfunc.__defaults__
         # get the specializer based on the tag of the 'pyobj'
         # (if any), according to the current policy
         tag = getattr(pyfunc, '_annspecialcase_', None)
@@ -582,7 +582,7 @@ def warning(self, msg):
 
 def origin_of_meth(boundmeth):
     func = boundmeth.im_func
-    candname = func.func_name
+    candname = func.__name__
     for cls in inspect.getmro(boundmeth.im_class):
         dict = cls.__dict__
         if dict.get(candname) is func:

rpython/flowspace/flowcontext.py

@@ -199,7 +199,7 @@ def UNARY_OP(self, *ignored):
         w_1 = self.popvalue()
         w_result = operation(w_1).eval(self)
         self.pushvalue(w_result)
-    UNARY_OP.func_name = OPCODE
+    UNARY_OP.__name__ = OPCODE
     return UNARY_OP
 
 _binary_ops = [
@@ -237,7 +237,7 @@ def BINARY_OP(self, _):
         w_1 = self.popvalue()
         w_result = operation(w_1, w_2).eval(self)
         self.pushvalue(w_result)
-    BINARY_OP.func_name = OPCODE
+    BINARY_OP.__name__ = OPCODE
     return BINARY_OP
 
 _unsupported_ops = [
@@ -258,7 +258,7 @@ def BINARY_OP(self, _):
 def unsupportedoperation(OPCODE, msg):
     def UNSUPPORTED(self, *ignored):
         raise FlowingError("%s is not RPython" % (msg,))
-    UNSUPPORTED.func_name = OPCODE
+    UNSUPPORTED.__name__ = OPCODE
     return UNSUPPORTED
 
 compare_method = [
@@ -281,10 +281,10 @@ def __init__(self, graph, code):
         self.graph = graph
         func = graph.func
         self.pycode = code
-        self.w_globals = Constant(func.func_globals)
+        self.w_globals = Constant(func.__globals__)
         self.blockstack = []
 
-        self.init_closure(func.func_closure)
+        self.init_closure(func.__closure__)
         self.f_lineno = code.co_firstlineno
         self.last_offset = 0
 

rpython/flowspace/generator.py

@@ -18,7 +18,7 @@ class AbstractPosition(object):
 def make_generator_entry_graph(func):
     # This is the first copy of the graph.  We replace it with
     # a small bootstrap graph.
-    code = HostCode._from_code(func.func_code)
+    code = HostCode._from_code(func.__code__)
     graph = PyGraph(func, code)
     block = graph.startblock
     for name, w_value in zip(code.co_varnames, block.framestate.mergeable):
@@ -69,7 +69,7 @@ def replace_graph_with_bootstrap(GeneratorIterator, graph):
 
 def attach_next_method(GeneratorIterator, graph):
     func = graph.func
-    func = func_with_new_name(func, '%s__next' % (func.func_name,))
+    func = func_with_new_name(func, '%s__next' % (func.__name__,))
     func._generator_next_method_of_ = GeneratorIterator
     func._always_inline_ = True
     #

rpython/flowspace/model.py

@@ -48,11 +48,11 @@ def source(self, value):
 
     @property
     def startline(self):
-        return self.func.func_code.co_firstlineno
+        return self.func.__code__.co_firstlineno
 
     @property
     def filename(self):
-        return self.func.func_code.co_filename
+        return self.func.__code__.co_filename
 
     def __str__(self):
         if hasattr(self, 'func'):

rpython/flowspace/objspace.py

@@ -14,23 +14,23 @@
 def _assert_rpythonic(func):
     """Raise ValueError if ``func`` is obviously not RPython"""
     try:
-        func.func_code.co_cellvars
+        func.__code__.co_cellvars
     except AttributeError:
         raise ValueError("%r is not RPython: it is likely an unexpected "
                          "built-in function or type" % (func,))
     if getattr(func, "_not_rpython_", False):
         raise ValueError("%r is tagged as @not_rpython" % (func,))
-    if func.func_doc and func.func_doc.lstrip().startswith('NOT_RPYTHON'):
+    if func.__doc__ and func.__doc__.lstrip().startswith('NOT_RPYTHON'):
         raise ValueError("%r is tagged as NOT_RPYTHON" % (func,))
-    if func.func_code.co_cellvars:
+    if func.__code__.co_cellvars:
         raise ValueError(
 """RPython functions cannot create closures
 Possible causes:
     Function is inner function
     Function uses generator expressions
     Lambda expressions
 in %r""" % (func,))
-    if not (func.func_code.co_flags & CO_NEWLOCALS):
+    if not (func.__code__.co_flags & CO_NEWLOCALS):
         raise ValueError("The code object for a RPython function should have "
                          "the flag CO_NEWLOCALS set.")
 
@@ -43,7 +43,7 @@ def build_flow(func):
     if (isgeneratorfunction(func) and
             not hasattr(func, '_generator_next_method_of_')):
         return make_generator_entry_graph(func)
-    code = HostCode._from_code(func.func_code)
+    code = HostCode._from_code(func.__code__)
     graph = PyGraph(func, code)
     ctx = FlowContext(graph, code)
     ctx.build_flow()

rpython/flowspace/pygraph.py

@@ -19,12 +19,12 @@ def __init__(self, func, code):
         super(PyGraph, self).__init__(self._sanitize_funcname(func), initialblock)
         self.func = func
         self.signature = code.signature
-        self.defaults = func.func_defaults or ()
+        self.defaults = func.__defaults__ or ()
 
     @staticmethod
     def _sanitize_funcname(func):
         # CallableFactory.pycall may add class_ to functions that are methods
-        name = func.func_name
+        name = func.__name__
         class_ = getattr(func, 'class_', None)
         if class_ is not None:
             name = '%s.%s' % (class_.__name__, name)

rpython/flowspace/test/test_framestate.py

@@ -10,7 +10,7 @@ def get_context(self, func):
             func = func.im_func
         except AttributeError:
             pass
-        code = HostCode._from_code(func.func_code)
+        code = HostCode._from_code(func.__code__)
         graph = PyGraph(func, code)
         ctx = FlowContext(graph, code)
         # hack the frame

rpython/flowspace/test/test_objspace.py

@@ -1015,7 +1015,7 @@ def f():
 
             # this code is generated by pypy-c when compiling above f
             pypy_code = 't\x00\x00\x83\x00\x00}\x00\x00|\x00\x00\xc9\x01\x00\xca\x00\x00S'
-            new_c = self.monkey_patch_code(f.func_code, 3, 3, pypy_code, ('X', 'x', 'm'), ('x',))
+            new_c = self.monkey_patch_code(f.__code__, 3, 3, pypy_code, ('X', 'x', 'm'), ('x',))
             f2 = types.FunctionType(new_c, locals(), 'f')
 
             graph = self.codetest(f2)
@@ -1034,7 +1034,7 @@ def f():
 
             # this code is generated by pypy-c when compiling above f
             pypy_code = 'd\x01\x00\xcb\x00\x00D]\x0c\x00}\x00\x00|\x00\x00^\x02\x00q\x07\x00S'
-            new_c = self.monkey_patch_code(f.func_code, 3, 67, pypy_code, (),
+            new_c = self.monkey_patch_code(f.__code__, 3, 67, pypy_code, (),
                                            ('i',))
             f2 = types.FunctionType(new_c, locals(), 'f')
 

rpython/jit/backend/llgraph/runner.py

@@ -1589,7 +1589,7 @@ def _op_default_implementation(self, descr, *args):
             # for all operations implemented in the blackhole interpreter
             return func(*args)
         #
-        _op_default_implementation.func_name = 'execute_' + opname
+        _op_default_implementation.__name__ = 'execute_' + opname
         return _op_default_implementation
 
     def _new_execute(opname):
@@ -1613,7 +1613,7 @@ def execute(self, descr, *args):
                 if count == 1:
                     result = result[0]
             return result
-        execute.func_name = 'execute_' + opname
+        execute.__name__ = 'execute_' + opname
         return execute
 
     for k, v in rop.__dict__.iteritems():