implement "@cython.inline" decorator for functions

scoder · scoder · commit fea7ad6e4d7e · 2014-05-23T14:25:14.000+02:00
diff --git a/CHANGES.rst b/CHANGES.rst
@@ -9,6 +9,9 @@ Latest
 Features added
 --------------
 
+* The ``inline`` function modifier is available as a decorator
+  ``@cython.inline`` in pure mode.
+
 * When cygdb is run in a virtualenv, it enables the same virtualenv
   inside of the debugger. Patch by Marc Abramowitz.
 
diff --git a/Cython/Compiler/Nodes.py b/Cython/Compiler/Nodes.py
@@ -2539,7 +2539,7 @@ def __init__(self, pos, **kwds):
         self.num_required_kw_args = rk
         self.num_required_args = r
 
-    def as_cfunction(self, cfunc=None, scope=None, overridable=True, returns=None):
+    def as_cfunction(self, cfunc=None, scope=None, overridable=True, returns=None, modifiers=None):
         if self.star_arg:
             error(self.star_arg.pos, "cdef function cannot have star argument")
         if self.starstar_arg:
@@ -2588,7 +2588,7 @@ def as_cfunction(self, cfunc=None, scope=None, overridable=True, returns=None):
                                          with_gil = cfunc_type.with_gil,
                                          nogil = cfunc_type.nogil)
         return CFuncDefNode(self.pos,
-                            modifiers = [],
+                            modifiers = modifiers or [],
                             base_type = CAnalysedBaseTypeNode(self.pos, type=cfunc_type.return_type),
                             declarator = declarator,
                             body = self.body,
diff --git a/Cython/Compiler/Options.py b/Cython/Compiler/Options.py
@@ -206,6 +206,7 @@ def normalise_encoding_name(option_name, encoding):
     'binding' : bool,
     'cfunc' : None, # decorators do not take directive value
     'ccall' : None,
+    'inline' : None,
     'cclass' : None,
     'returns' : type,
     'set_initial_path': str,
@@ -221,6 +222,7 @@ def normalise_encoding_name(option_name, encoding):
 directive_scopes = { # defaults to available everywhere
     # 'module', 'function', 'class', 'with statement'
     'final' : ('cclass', 'function'),
+    'inline' : ('function',),
     'no_gc_clear' : ('cclass',),
     'internal' : ('cclass',),
     'autotestdict' : ('module',),
diff --git a/Cython/Compiler/ParseTreeTransforms.py b/Cython/Compiler/ParseTreeTransforms.py
@@ -2011,13 +2011,15 @@ def visit_ExprNode(self, node):
         # In-place assignments can't happen within an expression.
         return node
 
+
 class AdjustDefByDirectives(CythonTransform, SkipDeclarations):
     """
     Adjust function and class definitions by the decorator directives:
 
     @cython.cfunc
     @cython.cclass
     @cython.ccall
+    @cython.inline
     """
 
     def visit_ModuleNode(self, node):
@@ -2034,15 +2036,22 @@ def visit_CompilerDirectivesNode(self, node):
         return node
 
     def visit_DefNode(self, node):
+        modifiers = []
+        if 'inline' in self.directives:
+            modifiers.append('inline')
         if 'ccall' in self.directives:
-            node = node.as_cfunction(overridable=True, returns=self.directives.get('returns'))
+            node = node.as_cfunction(
+                overridable=True, returns=self.directives.get('returns'), modifiers=modifiers)
             return self.visit(node)
         if 'cfunc' in self.directives:
             if self.in_py_class:
                 error(node.pos, "cfunc directive is not allowed here")
             else:
-                node = node.as_cfunction(overridable=False, returns=self.directives.get('returns'))
+                node = node.as_cfunction(
+                    overridable=False, returns=self.directives.get('returns'), modifiers=modifiers)
                 return self.visit(node)
+        if 'inline' in modifiers:
+            error(node.pos, "Python functions cannot be declared 'inline'")
         self.visitchildren(node)
         return node
 
diff --git a/docs/src/tutorial/pure.rst b/docs/src/tutorial/pure.rst
@@ -164,7 +164,8 @@ Use the ``@cython.cfunc`` decorator for :keyword:`cdef` functions
 and the ``@cython.ccall`` decorators for :keyword:`cpdef` functions
 respectively.  To declare the argument types, use the
 ``@cython.locals()`` decorator.  For the return type, use
-``@cython.returns(a_type)``.
+``@cython.returns(a_type)``.  The C ``inline`` modifier is available
+as ``@cython.inline`` decorator.
 
 Here is an example of a :keyword:`cdef` function::
 
diff --git a/tests/run/pure_py.py b/tests/run/pure_py.py
@@ -173,6 +173,7 @@ def test_declare_c_types(n):
     #z02 = cython.declare(cython.doublecomplex, n+1j)
     #z03 = cython.declare(cython.longdoublecomplex, n+1j)
 
+
 @cython.ccall
 @cython.returns(cython.double)
 def c_call(x):
@@ -193,6 +194,30 @@ def c_call(x):
     """
     return x
 
+
 def call_ccall(x):
     ret = c_call(x)
     return ret, cython.typeof(ret)
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.double)
+def cdef_inline(x):
+    """
+    >>> result, return_type = call_cdef_inline(1)
+    >>> (not is_compiled and 'float') or type(return_type).__name__
+    'float'
+    >>> (not is_compiled and 'double') or return_type
+    'double'
+    >>> (is_compiled and 'int') or return_type
+    'int'
+    >>> result == 2.0  or  result
+    True
+    """
+    return x + 1
+
+
+def call_cdef_inline(x):
+    ret = cdef_inline(x)
+    return ret, cython.typeof(ret)
