Merge pull request #115 from markflorisson88/_fused_dispatch_rebased

fused runtime dispatch for buffers

Cython/Compiler/Code.py

@@ -14,6 +14,7 @@ import re
 import sys
 from string import Template
 import operator
+import textwrap
 
 import Naming
 import Options
@@ -376,7 +377,7 @@ class UtilityCode(UtilityCodeBase):
                 self.cleanup(writer, output.module_pos)
 
 
-def sub_tempita(s, context, file, name):
+def sub_tempita(s, context, file=None, name=None):
     "Run tempita on string s with given context."
     if not s:
         return None
@@ -1940,6 +1941,75 @@ class PyrexCodeWriter(object):
     def dedent(self):
         self.level -= 1
 
+class PyxCodeWriter(object):
+    """
+    Can be used for writing out some Cython code. To use the indenter
+    functionality, the Cython.Compiler.Importer module will have to be used
+    to load the code to support python 2.4
+    """
+
+    def __init__(self, buffer=None, indent_level=0, context=None, encoding='ascii'):
+        self.buffer = buffer or StringIOTree()
+        self.level = indent_level
+        self.context = context
+        self.encoding = encoding
+
+    def indent(self, levels=1):
+        self.level += levels
+        return True
+
+    def dedent(self, levels=1):
+        self.level -= levels
+
+    def indenter(self, line):
+        """
+        Instead of
+
+            with pyx_code.indenter("for i in range(10):"):
+                pyx_code.putln("print i")
+
+        write
+
+            if pyx_code.indenter("for i in range(10);"):
+                pyx_code.putln("print i")
+                pyx_code.dedent()
+        """
+        self.putln(line)
+        self.indent()
+        return True
+
+    def getvalue(self):
+        result = self.buffer.getvalue()
+        if not isinstance(result, unicode):
+            result = result.decode(self.encoding)
+
+        return result
+
+    def putln(self, line, context=None):
+        context = context or self.context
+        if context:
+            line = sub_tempita(line, context)
+        self._putln(line)
+
+    def _putln(self, line):
+        self.buffer.write("%s%s\n" % (self.level * "    ", line))
+
+    def put_chunk(self, chunk, context=None):
+        context = context or self.context
+        if context:
+            chunk = sub_tempita(chunk, context)
+
+        chunk = textwrap.dedent(chunk)
+        for line in chunk.splitlines():
+            self._putln(line)
+
+    def insertion_point(self):
+        return PyxCodeWriter(self.buffer.insertion_point(), self.level,
+                             self.context)
+
+    def named_insertion_point(self, name):
+        setattr(self, name, self.insertion_point())
+
 
 class ClosureTempAllocator(object):
     def __init__(self, klass):

Cython/Compiler/ExprNodes.py

@@ -6245,7 +6245,7 @@ class PyCFunctionNode(ExprNode, ModuleNameMixin):
                 else:
                     arg.default = DefaultLiteralArgNode(arg.pos, arg.default)
                 default_args.append(arg)
-        if nonliteral_objects or nonliteral_objects:
+        if nonliteral_objects or nonliteral_other:
             module_scope = env.global_scope()
             cname = module_scope.next_id(Naming.defaults_struct_prefix)
             scope = Symtab.StructOrUnionScope(cname)

Cython/Compiler/FusedNode.py

+import copy
+
+from Cython.Compiler import (ExprNodes, PyrexTypes, MemoryView,
+                             ParseTreeTransforms, StringEncoding,
+                             Errors)
+from Cython.Compiler.ExprNodes import CloneNode, ProxyNode, TupleNode
+from Cython.Compiler.Nodes import (FuncDefNode, CFuncDefNode, StatListNode,
+                                   DefNode)
+
+class FusedCFuncDefNode(StatListNode):
+    """
+    This node replaces a function with fused arguments. It deep-copies the
+    function for every permutation of fused types, and allocates a new local
+    scope for it. It keeps track of the original function in self.node, and
+    the entry of the original function in the symbol table is given the
+    'fused_cfunction' attribute which points back to us.
+    Then when a function lookup occurs (to e.g. call it), the call can be
+    dispatched to the right function.
+
+    node    FuncDefNode    the original function
+    nodes   [FuncDefNode]  list of copies of node with different specific types
+    py_func DefNode        the fused python function subscriptable from
+                           Python space
+    __signatures__         A DictNode mapping signature specialization strings
+                           to PyCFunction nodes
+    resulting_fused_function  PyCFunction for the fused DefNode that delegates
+                              to specializations
+    fused_func_assignment   Assignment of the fused function to the function name
+    defaults_tuple          TupleNode of defaults (letting PyCFunctionNode build
+                            defaults would result in many different tuples)
+    specialized_pycfuncs    List of synthesized pycfunction nodes for the
+                            specializations
+    code_object             CodeObjectNode shared by all specializations and the
+                            fused function
+    """
+
+    __signatures__ = None
+    resulting_fused_function = None
+    fused_func_assignment = None
+    defaults_tuple = None
+
+    def __init__(self, node, env):
+        super(FusedCFuncDefNode, self).__init__(node.pos)
+
+        self.nodes = []
+        self.node = node
+
+        is_def = isinstance(self.node, DefNode)
+        if is_def:
+            self.copy_def(env)
+        else:
+            self.copy_cdef(env)
+
+        # Perform some sanity checks. If anything fails, it's a bug
+        for n in self.nodes:
+            assert not n.entry.type.is_fused
+            assert not n.local_scope.return_type.is_fused
+            if node.return_type.is_fused:
+                assert not n.return_type.is_fused
+
+            if not is_def and n.cfunc_declarator.optional_arg_count:
+                assert n.type.op_arg_struct
+
+        node.entry.fused_cfunction = self
+        # Copy the nodes as AnalyseDeclarationsTransform will prepend
+        # self.py_func to self.stats, as we only want specialized
+        # CFuncDefNodes in self.nodes
+        self.stats = self.nodes[:]
+
+    def copy_def(self, env):
+        """
+        Create a copy of the original def or lambda function for specialized
+        versions.
+        """
+        fused_compound_types = PyrexTypes.unique(
+            [arg.type for arg in self.node.args if arg.type.is_fused])
+        permutations = PyrexTypes.get_all_specialized_permutations(fused_compound_types)
+
+        if self.node.entry in env.pyfunc_entries:
+            env.pyfunc_entries.remove(self.node.entry)
+
+        for cname, fused_to_specific in permutations:
+            copied_node = copy.deepcopy(self.node)
+
+            self._specialize_function_args(copied_node.args, fused_to_specific)
+            copied_node.return_type = self.node.return_type.specialize(
+                                                    fused_to_specific)
+
+            copied_node.analyse_declarations(env)
+            self.create_new_local_scope(copied_node, env, fused_to_specific)
+            self.specialize_copied_def(copied_node, cname, self.node.entry,
+                                       fused_to_specific, fused_compound_types)
+
+            PyrexTypes.specialize_entry(copied_node.entry, cname)
+            copied_node.entry.used = True
+            env.entries[copied_node.entry.name] = copied_node.entry
+
+            if not self.replace_fused_typechecks(copied_node):
+                break
+
+        self.orig_py_func = self.node
+        self.py_func = self.make_fused_cpdef(self.node, env, is_def=True)
+
+    def copy_cdef(self, env):
+        """
+        Create a copy of the original c(p)def function for all specialized
+        versions.
+        """
+        permutations = self.node.type.get_all_specialized_permutations()
+        # print 'Node %s has %d specializations:' % (self.node.entry.name,
+        #                                            len(permutations))
+        # import pprint; pprint.pprint([d for cname, d in permutations])
+
+        if self.node.entry in env.cfunc_entries:
+            env.cfunc_entries.remove(self.node.entry)
+
+        # Prevent copying of the python function
+        self.orig_py_func = orig_py_func = self.node.py_func
+        self.node.py_func = None
+        if orig_py_func:
+            env.pyfunc_entries.remove(orig_py_func.entry)
+
+        fused_types = self.node.type.get_fused_types()
+
+        for cname, fused_to_specific in permutations:
+            copied_node = copy.deepcopy(self.node)
+
+            # Make the types in our CFuncType specific
+            type = copied_node.type.specialize(fused_to_specific)
+            entry = copied_node.entry
+
+            copied_node.type = type
+            entry.type, type.entry = type, entry
+
+            entry.used = (entry.used or
+                          self.node.entry.defined_in_pxd or
+                          env.is_c_class_scope or
+                          entry.is_cmethod)
+
+            if self.node.cfunc_declarator.optional_arg_count:
+                self.node.cfunc_declarator.declare_optional_arg_struct(
+                                           type, env, fused_cname=cname)
+
+            copied_node.return_type = type.return_type
+            self.create_new_local_scope(copied_node, env, fused_to_specific)
+
+            # Make the argument types in the CFuncDeclarator specific
+            self._specialize_function_args(copied_node.cfunc_declarator.args,
+                                           fused_to_specific)
+
+            type.specialize_entry(entry, cname)
+            env.cfunc_entries.append(entry)
+
+            # If a cpdef, declare all specialized cpdefs (this
+            # also calls analyse_declarations)
+            copied_node.declare_cpdef_wrapper(env)
+            if copied_node.py_func:
+                env.pyfunc_entries.remove(copied_node.py_func.entry)
+
+                self.specialize_copied_def(
+                        copied_node.py_func, cname, self.node.entry.as_variable,
+                        fused_to_specific, fused_types)
+
+            if not self.replace_fused_typechecks(copied_node):
+                break
+
+        if orig_py_func:
+            self.py_func = self.make_fused_cpdef(orig_py_func, env,
+                                                 is_def=False)
+        else:
+            self.py_func = orig_py_func
+
+    def _specialize_function_args(self, args, fused_to_specific):
+        for arg in args:
+            if arg.type.is_fused:
+                arg.type = arg.type.specialize(fused_to_specific)
+                if arg.type.is_memoryviewslice:
+                    MemoryView.validate_memslice_dtype(arg.pos, arg.type.dtype)
+
+    def create_new_local_scope(self, node, env, f2s):
+        """
+        Create a new local scope for the copied node and append it to
+        self.nodes. A new local scope is needed because the arguments with the
+        fused types are aready in the local scope, and we need the specialized
+        entries created after analyse_declarations on each specialized version
+        of the (CFunc)DefNode.
+        f2s is a dict mapping each fused type to its specialized version
+        """
+        node.create_local_scope(env)
+        node.local_scope.fused_to_specific = f2s
+
+        # This is copied from the original function, set it to false to
+        # stop recursion
+        node.has_fused_arguments = False
+        self.nodes.append(node)
+
+    def specialize_copied_def(self, node, cname, py_entry, f2s, fused_types):
+        """Specialize the copy of a DefNode given the copied node,
+        the specialization cname and the original DefNode entry"""
+        type_strings = [
+            PyrexTypes.specialization_signature_string(fused_type, f2s)
+                for fused_type in fused_types
+        ]
+
+        node.specialized_signature_string = ', '.join(type_strings)
+
+        node.entry.pymethdef_cname = PyrexTypes.get_fused_cname(
+                                        cname, node.entry.pymethdef_cname)
+        node.entry.doc = py_entry.doc
+        node.entry.doc_cname = py_entry.doc_cname
+
+    def replace_fused_typechecks(self, copied_node):
+        """
+        Branch-prune fused type checks like
+
+            if fused_t is int:
+                ...
+
+        Returns whether an error was issued and whether we should stop in
+        in order to prevent a flood of errors.
+        """
+        num_errors = Errors.num_errors
+        transform = ParseTreeTransforms.ReplaceFusedTypeChecks(
+                                       copied_node.local_scope)
+        transform(copied_node)
+
+        if Errors.num_errors > num_errors:
+            return False
+
+        return True
+
+    def _fused_instance_checks(self, normal_types, pyx_code, env):
+        """
+        Genereate Cython code for instance checks, matching an object to
+        specialized types.
+        """
+        if_ = 'if'
+        for specialized_type in normal_types:
+            # all_numeric = all_numeric and specialized_type.is_numeric
+            py_type_name = specialized_type.py_type_name()
+
+            # in the case of long, unicode or bytes we need to instance
+            # check for long_, unicode_, bytes_ (long = long is no longer
+            # valid code with control flow analysis)
+            specialized_check_name = py_type_name
+            if py_type_name in ('long', 'unicode', 'bytes'):
+                specialized_check_name += '_'
+
+            specialized_type_name = specialized_type.specialization_string
+            pyx_code.context.update(locals())
+            pyx_code.put_chunk(
+                u"""
+                    {{if_}} isinstance(arg, {{specialized_check_name}}):
+                        dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'
+                """)
+            if_ = 'elif'
+
+        if not normal_types:
+            # we need an 'if' to match the following 'else'
+            pyx_code.putln("if 0: pass")
+
+    def _dtype_name(self, dtype):
+        if dtype.is_typedef:
+            return '___pyx_%s' % dtype
+        return str(dtype).replace(' ', '_')
+
+    def _dtype_type(self, dtype):
+        if dtype.is_typedef:
+            return self._dtype_name(dtype)
+        return str(dtype)
+
+    def _sizeof_dtype(self, dtype):
+        if dtype.is_pyobject:
+            return 'sizeof(void *)'
+        else:
+            return "sizeof(%s)" % self._dtype_type(dtype)
+
+    def _buffer_check_numpy_dtype_setup_cases(self, pyx_code):
+        "Setup some common cases to match dtypes against specializations"
+        if pyx_code.indenter("if dtype.kind in ('i', 'u'):"):
+            pyx_code.putln("pass")
+            pyx_code.named_insertion_point("dtype_int")
+            pyx_code.dedent()
+
+        if pyx_code.indenter("elif dtype.kind == 'f':"):
+            pyx_code.putln("pass")
+            pyx_code.named_insertion_point("dtype_float")
+            pyx_code.dedent()
+
+        if pyx_code.indenter("elif dtype.kind == 'c':"):
+            pyx_code.putln("pass")
+            pyx_code.named_insertion_point("dtype_complex")
+            pyx_code.dedent()
+
+        if pyx_code.indenter("elif dtype.kind == 'O':"):
+            pyx_code.putln("pass")
+            pyx_code.named_insertion_point("dtype_object")
+            pyx_code.dedent()
+
+    match = "dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'"
+    no_match = "dest_sig[{{dest_sig_idx}}] = None"
+    def _buffer_check_numpy_dtype(self, pyx_code, specialized_buffer_types):
+        """
+        Match a numpy dtype object to the individual specializations.
+        """
+        self._buffer_check_numpy_dtype_setup_cases(pyx_code)
+
+        for specialized_type in specialized_buffer_types:
+            dtype = specialized_type.dtype
+            pyx_code.context.update(
+                itemsize_match=self._sizeof_dtype(dtype) + " == itemsize",
+                signed_match="not (%s_is_signed ^ dtype_signed)" % self._dtype_name(dtype),
+                dtype=dtype,
+                specialized_type_name=specialized_type.specialization_string)
+
+            dtypes = [
+                (dtype.is_int, pyx_code.dtype_int),
+                (dtype.is_float, pyx_code.dtype_float),
+                (dtype.is_complex, pyx_code.dtype_complex)
+            ]
+
+            for dtype_category, codewriter in dtypes:
+                if dtype_category:
+                    cond = '{{itemsize_match}}'
+                    if dtype.is_int:
+                        cond += ' and {{signed_match}}'
+
+                    if codewriter.indenter("if %s:" % cond):
+                        # codewriter.putln("print 'buffer match found based on numpy dtype'")
+                        codewriter.putln(self.match)
+                        codewriter.putln("break")
+                        codewriter.dedent()
+
+    def _buffer_parse_format_string_check(self, pyx_code, decl_code,
+                                          specialized_type, env):
+        """
+        For each specialized type, try to coerce the object to a memoryview
+        slice of that type. This means obtaining a buffer and parsing the
+        format string.
+        TODO: separate buffer acquisition from format parsing
+        """
+        dtype = specialized_type.dtype
+        if specialized_type.is_buffer:
+            axes = [('direct', 'strided')] * specialized_type.ndim
+        else:
+            axes = specialized_type.axes
+
+        memslice_type = PyrexTypes.MemoryViewSliceType(dtype, axes)
+        memslice_type.create_from_py_utility_code(env)
+        pyx_code.context.update(
+            coerce_from_py_func=memslice_type.from_py_function,
+            dtype=dtype)
+        decl_code.putln(
+            "{{memviewslice_cname}} {{coerce_from_py_func}}(object)")
+
+        pyx_code.context.update(
+            specialized_type_name=specialized_type.specialization_string,
+            sizeof_dtype=self._sizeof_dtype(dtype))
+
+        pyx_code.put_chunk(
+            u"""
+                # try {{dtype}}
+                if itemsize == -1 or itemsize == {{sizeof_dtype}}:
+                    memslice = {{coerce_from_py_func}}(arg)
+                    if memslice.memview:
+                        __PYX_XDEC_MEMVIEW(&memslice, 1)
+                        # print 'found a match for the buffer through format parsing'
+                        %s
+                        break
+                    else:
+                        PyErr_Clear()
+            """ % self.match)
+
+    def _buffer_checks(self, buffer_types, pyx_code, decl_code, env):
+        """
+        Generate Cython code to match objects to buffer specializations.
+        First try to get a numpy dtype object and match it against the individual
+        specializations. If that fails, try naively to coerce the object
+        to each specialization, which obtains the buffer each time and tries
+        to match the format string.
+        """
+        from Cython.Compiler import ExprNodes
+        if buffer_types:
+            if pyx_code.indenter(u"else:"):
+                # The first thing to find a match in this loop breaks out of the loop
+                if pyx_code.indenter(u"while 1:"):
+                    pyx_code.put_chunk(
+                        u"""
+                            if numpy is not None:
+                                if isinstance(arg, numpy.ndarray):
+                                    dtype = arg.dtype
+                                elif (__pyx_memoryview_check(arg) and
+                                      isinstance(arg.base, numpy.ndarray)):
+                                    dtype = arg.base.dtype
+                                else:
+                                    dtype = None
+
+                                itemsize = -1
+                                if dtype is not None:
+                                    itemsize = dtype.itemsize
+                                    kind = ord(dtype.kind)
+                                    dtype_signed = kind == ord('i')
+                        """)
+                    pyx_code.indent(2)
+                    pyx_code.named_insertion_point("numpy_dtype_checks")
+                    self._buffer_check_numpy_dtype(pyx_code, buffer_types)
+                    pyx_code.dedent(2)
+
+                    for specialized_type in buffer_types:
+                        self._buffer_parse_format_string_check(
+                                pyx_code, decl_code, specialized_type, env)
+
+                    pyx_code.putln(self.no_match)
+                    pyx_code.putln("break")
+                    pyx_code.dedent()
+
+                pyx_code.dedent()
+        else:
+            pyx_code.putln("else: %s" % self.no_match)
+
+    def _buffer_declarations(self, pyx_code, decl_code, all_buffer_types):
+        """
+        If we have any buffer specializations, write out some variable
+        declarations and imports.
+        """
+        decl_code.put_chunk(
+            u"""
+                ctypedef struct {{memviewslice_cname}}:
+                    void *memview
+
+                void __PYX_XDEC_MEMVIEW({{memviewslice_cname}} *, int have_gil)
+                bint __pyx_memoryview_check(object)
+            """)
+
+        pyx_code.local_variable_declarations.put_chunk(
+            u"""
+                cdef {{memviewslice_cname}} memslice
+                cdef Py_ssize_t itemsize
+                cdef bint dtype_signed
+                cdef char kind
+
+                itemsize = -1
+            """)
+
+        pyx_code.imports.put_chunk(
+            u"""
+                try:
+                    import numpy
+                except ImportError:
+                    numpy = None
+            """)
+
+        seen_int_dtypes = set()
+        for buffer_type in all_buffer_types:
+            dtype = buffer_type.dtype
+            if dtype.is_typedef:
+                 #decl_code.putln("ctypedef %s %s" % (dtype.resolve(),
+                 #                                    self._dtype_name(dtype)))
+                decl_code.putln('ctypedef %s %s "%s"' % (dtype.resolve(),
+                                                         self._dtype_name(dtype),
+                                                         dtype.declaration_code("")))
+
+            if buffer_type.dtype.is_int:
+                if str(dtype) not in seen_int_dtypes:
+                    seen_int_dtypes.add(str(dtype))
+                    pyx_code.context.update(dtype_name=self._dtype_name(dtype),
+                                            dtype_type=self._dtype_type(dtype))
+                    pyx_code.local_variable_declarations.put_chunk(
+                        u"""
+                            cdef bint {{dtype_name}}_is_signed
+                            {{dtype_name}}_is_signed = <{{dtype_type}}> -1 < 0
+                        """)
+
+    def _split_fused_types(self, arg):
+        """
+        Specialize fused types and split into normal types and buffer types.
+        """
+        specialized_types = PyrexTypes.get_specialized_types(arg.type)
+        # Prefer long over int, etc
+        # specialized_types.sort()
+        seen_py_type_names = set()
+        normal_types, buffer_types = [], []
+        for specialized_type in specialized_types:
+            py_type_name = specialized_type.py_type_name()
+            if py_type_name:
+                if py_type_name in seen_py_type_names:
+                    continue
+                seen_py_type_names.add(py_type_name)
+                normal_types.append(specialized_type)
+            elif specialized_type.is_buffer or specialized_type.is_memoryviewslice:
+                buffer_types.append(specialized_type)
+
+        return normal_types, buffer_types
+
+    def _unpack_argument(self, pyx_code):
+        pyx_code.put_chunk(
+            u"""
+                # PROCESSING ARGUMENT {{arg_tuple_idx}}
+                if {{arg_tuple_idx}} < len(args):
+                    arg = args[{{arg_tuple_idx}}]
+                elif '{{arg.name}}' in kwargs:
+                    arg = kwargs['{{arg.name}}']
+                else:
+                {{if arg.default:}}
+                    arg = defaults[{{default_idx}}]
+                {{else}}
+                    raise TypeError("Expected at least %d arguments" % len(args))
+                {{endif}}
+            """)
+
+    def make_fused_cpdef(self, orig_py_func, env, is_def):
+        """
+        This creates the function that is indexable from Python and does
+        runtime dispatch based on the argument types. The function gets the
+        arg tuple and kwargs dict (or None) and the defaults tuple
+        as arguments from the Binding Fused Function's tp_call.
+        """
+        from Cython.Compiler import TreeFragment, Code, MemoryView, UtilityCode
+
+        # { (arg_pos, FusedType) : specialized_type }
+        seen_fused_types = set()
+
+        context = {
+            'memviewslice_cname': MemoryView.memviewslice_cname,
+            'func_args': self.node.args,
+            'n_fused': len([arg for arg in self.node.args]),
+            'name': orig_py_func.entry.name,
+        }
+
+        pyx_code = Code.PyxCodeWriter(context=context)
+        decl_code = Code.PyxCodeWriter(context=context)
+        decl_code.put_chunk(
+            u"""
+                cdef extern from *:
+                    void PyErr_Clear()
+            """)
+        decl_code.indent()
+
+        pyx_code.put_chunk(
+            u"""
+                def __pyx_fused_cpdef(signatures, args, kwargs, defaults):
+                    import sys
+                    if sys.version_info >= (3, 0):
+                        long_ = int
+                        unicode_ = str
+                        bytes_ = bytes
+                    else:
+                        long_ = long
+                        unicode_ = unicode
+                        bytes_ = str
+
+                    dest_sig = [None] * {{n_fused}}
+
+                    if kwargs is None:
+                        kwargs = {}
+
+                    cdef Py_ssize_t i
+
+                    # instance check body
+            """)
+        pyx_code.indent() # indent following code to function body
+        pyx_code.named_insertion_point("imports")
+        pyx_code.named_insertion_point("local_variable_declarations")
+
+        fused_index = 0
+        default_idx = 0
+        all_buffer_types = set()
+        for i, arg in enumerate(self.node.args):
+            if arg.type.is_fused and arg.type not in seen_fused_types:
+                seen_fused_types.add(arg.type)
+
+                context.update(
+                    arg_tuple_idx=i,
+                    arg=arg,
+                    dest_sig_idx=fused_index,
+                    default_idx=default_idx,
+                )
+
+                normal_types, buffer_types = self._split_fused_types(arg)
+                self._unpack_argument(pyx_code)
+                self._fused_instance_checks(normal_types, pyx_code, env)
+                self._buffer_checks(buffer_types, pyx_code, decl_code, env)
+                fused_index += 1
+
+                all_buffer_types.update(buffer_types)
+
+            if arg.default:
+                default_idx += 1
+
+        if all_buffer_types:
+            self._buffer_declarations(pyx_code, decl_code, all_buffer_types)
+
+        pyx_code.put_chunk(
+            u"""
+                candidates = []
+                for sig in signatures:
+                    match_found = filter(None, dest_sig)
+                    for src_type, dst_type in zip(sig.strip('()').split(', '), dest_sig):
+                        if dst_type is not None and match_found:
+                            match_found = src_type == dst_type
+
+                    if match_found:
+                        candidates.append(sig)
+
+                if not candidates:
+                    raise TypeError("No matching signature found")
+                elif len(candidates) > 1:
+                    raise TypeError("Function call with ambiguous argument types")
+                else:
+                    return signatures[candidates[0]]
+            """)
+
+        fragment_code = pyx_code.getvalue()
+        # print decl_code.getvalue()
+        # print fragment_code
+        fragment = TreeFragment.TreeFragment(fragment_code, level='module')
+        ast = TreeFragment.SetPosTransform(self.node.pos)(fragment.root)
+        UtilityCode.declare_declarations_in_scope(decl_code.getvalue(), env)
+        ast.scope = env
+        ast.analyse_declarations(env)
+        py_func = ast.stats[-1] # the DefNode
+        self.fragment_scope = ast.scope
+
+        if isinstance(self.node, DefNode):
+            py_func.specialized_cpdefs = self.nodes[:]
+        else:
+            py_func.specialized_cpdefs = [n.py_func for n in self.nodes]
+
+        return py_func
+
+    def update_fused_defnode_entry(self, env):
+        copy_attributes = (
+            'name', 'pos', 'cname', 'func_cname', 'pyfunc_cname',
+            'pymethdef_cname', 'doc', 'doc_cname', 'is_member',
+            'scope'
+        )
+
+        entry = self.py_func.entry
+
+        for attr in copy_attributes:
+            setattr(entry, attr,
+                    getattr(self.orig_py_func.entry, attr))
+
+        self.py_func.name = self.orig_py_func.name
+        self.py_func.doc = self.orig_py_func.doc
+
+        env.entries.pop('__pyx_fused_cpdef', None)
+        if isinstance(self.node, DefNode):
+            env.entries[entry.name] = entry
+        else:
+            env.entries[entry.name].as_variable = entry
+
+        env.pyfunc_entries.append(entry)
+
+        self.py_func.entry.fused_cfunction = self
+        for node in self.nodes:
+            if isinstance(self.node, DefNode):
+                node.fused_py_func = self.py_func
+            else:
+                node.py_func.fused_py_func = self.py_func
+                node.entry.as_variable = entry
+
+        self.synthesize_defnodes()
+        self.stats.append(self.__signatures__)
+
+        env.use_utility_code(ExprNodes.import_utility_code)
+
+    def analyse_expressions(self, env):
+        """
+        Analyse the expressions. Take care to only evaluate default arguments
+        once and clone the result for all specializations
+        """
+        if self.py_func:
+            self.__signatures__.analyse_expressions(env)
+            self.py_func.analyse_expressions(env)
+            self.resulting_fused_function.analyse_expressions(env)
+            self.fused_func_assignment.analyse_expressions(env)
+
+        self.defaults = defaults = []
+
+        for arg in self.node.args:
+            if arg.default:
+                arg.default.analyse_expressions(env)
+                defaults.append(ProxyNode(arg.default))
+            else:
+                defaults.append(None)
+
+        for stat in self.stats:
+            stat.analyse_expressions(env)
+            if isinstance(stat, FuncDefNode):
+                for arg, default in zip(stat.args, defaults):
+                    if default is not None:
+                        arg.default = CloneNode(default).coerce_to(arg.type, env)
+
+        if self.py_func:
+            args = [CloneNode(default) for default in defaults if default]
+            self.defaults_tuple = TupleNode(self.pos, args=args)
+            self.defaults_tuple.analyse_types(env, skip_children=True)
+            self.defaults_tuple = ProxyNode(self.defaults_tuple)
+            self.code_object = ProxyNode(self.specialized_pycfuncs[0].code_object)
+
+            fused_func = self.resulting_fused_function.arg
+            fused_func.defaults_tuple = CloneNode(self.defaults_tuple)
+            fused_func.code_object = CloneNode(self.code_object)
+
+            for pycfunc in self.specialized_pycfuncs:
+                pycfunc.code_object = CloneNode(self.code_object)
+                pycfunc.analyse_types(env)
+                pycfunc.defaults_tuple = CloneNode(self.defaults_tuple)
+
+    def synthesize_defnodes(self):
+        """
+        Create the __signatures__ dict of PyCFunctionNode specializations.
+        """
+        if isinstance(self.nodes[0], CFuncDefNode):
+            nodes = [node.py_func for node in self.nodes]
+        else:
+            nodes = self.nodes
+
+        signatures = [
+            StringEncoding.EncodedString(node.specialized_signature_string)
+                for node in nodes]
+        keys = [ExprNodes.StringNode(node.pos, value=sig)
+                    for node, sig in zip(nodes, signatures)]
+        values = [ExprNodes.PyCFunctionNode.from_defnode(node, True)
+                              for node in nodes]
+        self.__signatures__ = ExprNodes.DictNode.from_pairs(self.pos,
+                                                            zip(keys, values))
+
+        self.specialized_pycfuncs = values
+        for pycfuncnode in values:
+            pycfuncnode.is_specialization = True
+
+    def generate_function_definitions(self, env, code):
+        if self.py_func:
+            self.py_func.pymethdef_required = True
+            self.fused_func_assignment.generate_function_definitions(env, code)
+
+        for stat in self.stats:
+            if isinstance(stat, FuncDefNode) and stat.entry.used:
+                code.mark_pos(stat.pos)
+                stat.generate_function_definitions(env, code)
+
+    def generate_execution_code(self, code):
+        # Note: all def function specialization are wrapped in PyCFunction
+        # nodes in the self.__signatures__ dictnode.
+        for default in self.defaults:
+            if default is not None:
+                default.generate_evaluation_code(code)
+
+        if self.py_func:
+            self.defaults_tuple.generate_evaluation_code(code)
+            self.code_object.generate_evaluation_code(code)
+
+        for stat in self.stats:
+            code.mark_pos(stat.pos)
+            if isinstance(stat, ExprNodes.ExprNode):
+                stat.generate_evaluation_code(code)
+            else:
+                stat.generate_execution_code(code)
+
+        if self.__signatures__:
+            self.resulting_fused_function.generate_evaluation_code(code)
+
+            code.putln(
+                "((__pyx_FusedFunctionObject *) %s)->__signatures__ = %s;" %
+                                    (self.resulting_fused_function.result(),
+                                     self.__signatures__.result()))
+            code.put_giveref(self.__signatures__.result())
+
+            self.fused_func_assignment.generate_execution_code(code)
+
+            # Dispose of results
+            self.resulting_fused_function.generate_disposal_code(code)
+            self.defaults_tuple.generate_disposal_code(code)
+            self.code_object.generate_disposal_code(code)
+
+        for default in self.defaults:
+            if default is not None:
+                default.generate_disposal_code(code)
+
+    def annotate(self, code):
+        for stat in self.stats:
+            stat.annotate(code)
\ No newline at end of file

Cython/Compiler/Nodes.py

@@ -2228,539 +2228,6 @@ class CFuncDefNode(FuncDefNode):
             code.putln('}')
 
 
-class FusedCFuncDefNode(StatListNode):
-    """
-    This node replaces a function with fused arguments. It deep-copies the
-    function for every permutation of fused types, and allocates a new local
-    scope for it. It keeps track of the original function in self.node, and
-    the entry of the original function in the symbol table is given the
-    'fused_cfunction' attribute which points back to us.
-    Then when a function lookup occurs (to e.g. call it), the call can be
-    dispatched to the right function.
-
-    node    FuncDefNode    the original function
-    nodes   [FuncDefNode]  list of copies of node with different specific types
-    py_func DefNode        the fused python function subscriptable from
-                           Python space
-    __signatures__         A DictNode mapping signature specialization strings
-                           to PyCFunction nodes
-    resulting_fused_function  PyCFunction for the fused DefNode that delegates
-                              to specializations
-    fused_func_assignment   Assignment of the fused function to the function name
-    defaults_tuple          TupleNode of defaults (letting PyCFunctionNode build
-                            defaults would result in many different tuples)
-    specialized_pycfuncs    List of synthesized pycfunction nodes for the
-                            specializations
-    code_object             CodeObjectNode shared by all specializations and the
-                            fused function
-    """
-
-    __signatures__ = None
-    resulting_fused_function = None
-    fused_func_assignment = None
-    defaults_tuple = None
-
-    def __init__(self, node, env):
-        super(FusedCFuncDefNode, self).__init__(node.pos)
-
-        self.nodes = []
-        self.node = node
-
-        is_def = isinstance(self.node, DefNode)
-        if is_def:
-            self.copy_def(env)
-        else:
-            self.copy_cdef(env)
-
-        # Perform some sanity checks. If anything fails, it's a bug
-        for n in self.nodes:
-            assert not n.entry.type.is_fused
-            assert not n.local_scope.return_type.is_fused
-            if node.return_type.is_fused:
-                assert not n.return_type.is_fused
-
-            if not is_def and n.cfunc_declarator.optional_arg_count:
-                assert n.type.op_arg_struct
-
-        node.entry.fused_cfunction = self
-
-        if self.py_func:
-            self.py_func.entry.fused_cfunction = self
-            for node in self.nodes:
-                if is_def:
-                    node.fused_py_func = self.py_func
-                else:
-                    node.py_func.fused_py_func = self.py_func
-                    node.entry.as_variable = self.py_func.entry
-        # Copy the nodes as AnalyseDeclarationsTransform will prepend
-        # self.py_func to self.stats, as we only want specialized
-        # CFuncDefNodes in self.nodes
-        self.stats = self.nodes[:]
-
-        if self.py_func:
-            self.synthesize_defnodes()
-            self.stats.append(self.__signatures__)
-
-    def copy_def(self, env):
-        """
-        Create a copy of the original def or lambda function for specialized
-        versions.
-        """
-        fused_compound_types = PyrexTypes.unique(
-            [arg.type for arg in self.node.args if arg.type.is_fused])
-        permutations = PyrexTypes.get_all_specialized_permutations(fused_compound_types)
-
-        if self.node.entry in env.pyfunc_entries:
-            env.pyfunc_entries.remove(self.node.entry)
-
-        for cname, fused_to_specific in permutations:
-            copied_node = copy.deepcopy(self.node)
-
-            self._specialize_function_args(copied_node.args, fused_to_specific)
-            copied_node.return_type = self.node.return_type.specialize(
-                                                    fused_to_specific)
-
-            copied_node.analyse_declarations(env)
-            self.create_new_local_scope(copied_node, env, fused_to_specific)
-            self.specialize_copied_def(copied_node, cname, self.node.entry,
-                                       fused_to_specific, fused_compound_types)
-
-            PyrexTypes.specialize_entry(copied_node.entry, cname)
-            copied_node.entry.used = True
-            env.entries[copied_node.entry.name] = copied_node.entry
-
-            if not self.replace_fused_typechecks(copied_node):
-                break
-
-        self.py_func = self.make_fused_cpdef(self.node, env, is_def=True)
-
-    def copy_cdef(self, env):
-        """
-        Create a copy of the original c(p)def function for all specialized
-        versions.
-        """
-        permutations = self.node.type.get_all_specialized_permutations()
-        # print 'Node %s has %d specializations:' % (self.node.entry.name,
-        #                                            len(permutations))
-        # import pprint; pprint.pprint([d for cname, d in permutations])
-
-        if self.node.entry in env.cfunc_entries:
-            env.cfunc_entries.remove(self.node.entry)
-
-        # Prevent copying of the python function
-        orig_py_func = self.node.py_func
-        self.node.py_func = None
-        if orig_py_func:
-            env.pyfunc_entries.remove(orig_py_func.entry)
-
-        fused_types = self.node.type.get_fused_types()
-
-        for cname, fused_to_specific in permutations:
-            copied_node = copy.deepcopy(self.node)
-
-            # Make the types in our CFuncType specific
-            type = copied_node.type.specialize(fused_to_specific)
-            entry = copied_node.entry
-
-            copied_node.type = type
-            entry.type, type.entry = type, entry
-
-            entry.used = (entry.used or
-                          self.node.entry.defined_in_pxd or
-                          env.is_c_class_scope or
-                          entry.is_cmethod)
-
-            if self.node.cfunc_declarator.optional_arg_count:
-                self.node.cfunc_declarator.declare_optional_arg_struct(
-                                           type, env, fused_cname=cname)
-
-            copied_node.return_type = type.return_type
-            self.create_new_local_scope(copied_node, env, fused_to_specific)
-
-            # Make the argument types in the CFuncDeclarator specific
-            self._specialize_function_args(copied_node.cfunc_declarator.args,
-                                           fused_to_specific)
-
-            type.specialize_entry(entry, cname)
-            env.cfunc_entries.append(entry)
-
-            # If a cpdef, declare all specialized cpdefs (this
-            # also calls analyse_declarations)
-            copied_node.declare_cpdef_wrapper(env)
-            if copied_node.py_func:
-                env.pyfunc_entries.remove(copied_node.py_func.entry)
-
-                self.specialize_copied_def(
-                        copied_node.py_func, cname, self.node.entry.as_variable,
-                        fused_to_specific, fused_types)
-
-            if not self.replace_fused_typechecks(copied_node):
-                break
-
-        if orig_py_func:
-            self.py_func = self.make_fused_cpdef(orig_py_func, env,
-                                                 is_def=False)
-        else:
-            self.py_func = orig_py_func
-
-    def _specialize_function_args(self, args, fused_to_specific):
-        import MemoryView
-        for arg in args:
-            if arg.type.is_fused:
-                arg.type = arg.type.specialize(fused_to_specific)
-                if arg.type.is_memoryviewslice:
-                    MemoryView.validate_memslice_dtype(arg.pos, arg.type.dtype)
-
-    def create_new_local_scope(self, node, env, f2s):
-        """
-        Create a new local scope for the copied node and append it to
-        self.nodes. A new local scope is needed because the arguments with the
-        fused types are aready in the local scope, and we need the specialized
-        entries created after analyse_declarations on each specialized version
-        of the (CFunc)DefNode.
-        f2s is a dict mapping each fused type to its specialized version
-        """
-        node.create_local_scope(env)
-        node.local_scope.fused_to_specific = f2s
-
-        # This is copied from the original function, set it to false to
-        # stop recursion
-        node.has_fused_arguments = False
-        self.nodes.append(node)
-
-    def specialize_copied_def(self, node, cname, py_entry, f2s, fused_types):
-        """Specialize the copy of a DefNode given the copied node,
-        the specialization cname and the original DefNode entry"""
-        type_strings = [
-            PyrexTypes.specialization_signature_string(fused_type, f2s)
-                for fused_type in fused_types
-        ]
-
-        node.specialized_signature_string = ', '.join(type_strings)
-
-        node.entry.pymethdef_cname = PyrexTypes.get_fused_cname(
-                                        cname, node.entry.pymethdef_cname)
-        node.entry.doc = py_entry.doc
-        node.entry.doc_cname = py_entry.doc_cname
-
-    def replace_fused_typechecks(self, copied_node):
-        """
-        Branch-prune fused type checks like
-
-            if fused_t is int:
-                ...
-
-        Returns whether an error was issued and whether we should stop in
-        in order to prevent a flood of errors.
-        """
-        from Cython.Compiler import ParseTreeTransforms
-
-        num_errors = Errors.num_errors
-        transform = ParseTreeTransforms.ReplaceFusedTypeChecks(
-                                       copied_node.local_scope)
-        transform(copied_node)
-
-        if Errors.num_errors > num_errors:
-            return False
-
-        return True
-
-    def make_fused_cpdef(self, orig_py_func, env, is_def):
-        """
-        This creates the function that is indexable from Python and does
-        runtime dispatch based on the argument types. The function gets the
-        arg tuple and kwargs dict (or None) as arugments from the Binding
-        Fused Function's tp_call.
-        """
-        from Cython.Compiler import TreeFragment
-        from Cython.Compiler import ParseTreeTransforms
-
-        # { (arg_pos, FusedType) : specialized_type }
-        seen_fused_types = set()
-
-        # list of statements that do the instance checks
-        body_stmts = []
-
-        args = self.node.args
-        for i, arg in enumerate(args):
-            arg_type = arg.type
-            if arg_type.is_fused and arg_type not in seen_fused_types:
-                seen_fused_types.add(arg_type)
-
-                specialized_types = PyrexTypes.get_specialized_types(arg_type)
-                # Prefer long over int, etc
-                # specialized_types.sort()
-
-                seen_py_type_names = set()
-                first_check = True
-
-                body_stmts.append(u"""
-    if nargs >= %(nextidx)d or '%(argname)s' in kwargs:
-        if nargs >= %(nextidx)d:
-            arg = args[%(idx)d]
-        else:
-            arg = kwargs['%(argname)s']
-""" % {'idx': i, 'nextidx': i + 1, 'argname': arg.name})
-
-                all_numeric = True
-                for specialized_type in specialized_types:
-                    py_type_name = specialized_type.py_type_name()
-
-                    if not py_type_name or py_type_name in seen_py_type_names:
-                        continue
-
-                    seen_py_type_names.add(py_type_name)
-
-                    all_numeric = all_numeric and specialized_type.is_numeric
-
-                    if first_check:
-                        if_ = 'if'
-                        first_check = False
-                    else:
-                        if_ = 'elif'
-
-                    # in the case of long, unicode or bytes we need to instance
-                    # check for long_, unicode_, bytes_ (long = long is no longer
-                    # valid code with control flow analysis)
-                    instance_check_py_type_name = py_type_name
-                    if py_type_name in ('long', 'unicode', 'bytes'):
-                        instance_check_py_type_name += '_'
-
-                    tup =  (if_, instance_check_py_type_name,
-                            len(seen_fused_types) - 1,
-                            specialized_type.typeof_name())
-                    body_stmts.append(
-                        "        %s isinstance(arg, %s): "
-                                     "dest_sig[%d] = '%s'" % tup)
-
-                if arg.default and all_numeric:
-                    arg.default.analyse_types(env)
-
-                    ts = specialized_types
-                    if arg.default.type.is_complex:
-                        typelist = [t for t in ts if t.is_complex]
-                    elif arg.default.type.is_float:
-                        typelist = [t for t in ts if t.is_float]
-                    else:
-                        typelist = [t for t in ts if t.is_int]
-
-                    if typelist:
-                        body_stmts.append(u"""\
-    else:
-        dest_sig[%d] = '%s'
-""" % (i, typelist[0].typeof_name()))
-
-        fmt_dict = {
-            'body': '\n'.join(body_stmts),
-            'nargs': len(args),
-            'name': orig_py_func.entry.name,
-        }
-
-        fragment_code = u"""
-def __pyx_fused_cpdef(signatures, args, kwargs):
-    #if len(args) < %(nargs)d:
-    #    raise TypeError("Invalid number of arguments, expected %(nargs)d, "
-    #                    "got %%d" %% len(args))
-    cdef int nargs
-    nargs = len(args)
-
-    import sys
-    if sys.version_info >= (3, 0):
-        long_ = int
-        unicode_ = str
-        bytes_ = bytes
-    else:
-        long_ = long
-        unicode_ = unicode
-        bytes_ = str
-
-    dest_sig = [None] * %(nargs)d
-
-    if kwargs is None:
-        kwargs = {}
-
-    # instance check body
-%(body)s
-
-    candidates = []
-    for sig in signatures:
-        match_found = [x for x in dest_sig if x]
-        for src_type, dst_type in zip(sig.strip('()').split(', '), dest_sig):
-            if dst_type is not None and match_found:
-                match_found = src_type == dst_type
-
-        if match_found:
-            candidates.append(sig)
-
-    if not candidates:
-        raise TypeError("No matching signature found")
-    elif len(candidates) > 1:
-        raise TypeError("Function call with ambiguous argument types")
-    else:
-        return signatures[candidates[0]]
-""" % fmt_dict
-
-        fragment = TreeFragment.TreeFragment(fragment_code, level='module')
-
-        # analyse the declarations of our fragment ...
-        py_func, = fragment.substitute(pos=self.node.pos).stats
-        # Analyse the function object ...
-        py_func.analyse_declarations(env)
-        # ... and its body
-        py_func.scope = env
-
-        # Will be analysed later by underlying AnalyseDeclarationsTransform
-        #ParseTreeTransforms.AnalyseDeclarationsTransform(None)(py_func)
-
-        e, orig_e = py_func.entry, orig_py_func.entry
-
-        # Update the new entry ...
-        py_func.name = e.name = orig_e.name
-        e.cname, e.func_cname = orig_e.cname, orig_e.func_cname
-        e.pymethdef_cname = orig_e.pymethdef_cname
-        e.doc, e.doc_cname = orig_e.doc, orig_e.doc_cname
-        # e.signature = TypeSlots.binaryfunc
-
-        py_func.doc = orig_py_func.doc
-
-        # ... and the symbol table
-        env.entries.pop('__pyx_fused_cpdef', None)
-        if is_def:
-            env.entries[e.name] = e
-        else:
-            env.entries[e.name].as_variable = e
-
-        env.pyfunc_entries.append(e)
-
-        if is_def:
-            py_func.specialized_cpdefs = self.nodes[:]
-        else:
-            py_func.specialized_cpdefs = [n.py_func for n in self.nodes]
-
-        return py_func
-
-    def analyse_expressions(self, env):
-        """
-        Analyse the expressions. Take care to only evaluate default arguments
-        once and clone the result for all specializations
-        """
-        from ExprNodes import CloneNode, ProxyNode, TupleNode
-
-        if self.py_func:
-            self.__signatures__.analyse_expressions(env)
-            self.py_func.analyse_expressions(env)
-            self.resulting_fused_function.analyse_expressions(env)
-            self.fused_func_assignment.analyse_expressions(env)
-
-        self.defaults = defaults = []
-
-        for arg in self.node.args:
-            if arg.default:
-                arg.default.analyse_expressions(env)
-                defaults.append(ProxyNode(arg.default))
-            else:
-                defaults.append(None)
-
-        for node in self.stats:
-            node.analyse_expressions(env)
-            if isinstance(node, FuncDefNode):
-                for arg, default in zip(node.args, defaults):
-                    if default is not None:
-                        arg.default = CloneNode(default).coerce_to(arg.type, env)
-
-        if self.py_func:
-            args = [CloneNode(default) for default in defaults if default]
-            defaults_tuple = TupleNode(self.pos, args=args)
-            defaults_tuple.analyse_types(env, skip_children=True)
-            self.defaults_tuple = ProxyNode(defaults_tuple)
-            self.code_object = ProxyNode(self.specialized_pycfuncs[0].code_object)
-
-            fused_func = self.resulting_fused_function.arg
-            fused_func.defaults_tuple = CloneNode(self.defaults_tuple)
-            fused_func.code_object = CloneNode(self.code_object)
-
-            for pycfunc in self.specialized_pycfuncs:
-                pycfunc.defaults_tuple = CloneNode(self.defaults_tuple)
-                pycfunc.code_object = CloneNode(self.code_object)
-
-    def synthesize_defnodes(self):
-        """
-        Create the __signatures__ dict of PyCFunctionNode specializations.
-        """
-        import ExprNodes, StringEncoding
-
-        if isinstance(self.nodes[0], CFuncDefNode):
-            nodes = [node.py_func for node in self.nodes]
-        else:
-            nodes = self.nodes
-
-        signatures = [
-            StringEncoding.EncodedString(node.specialized_signature_string)
-                for node in nodes]
-        keys = [ExprNodes.StringNode(node.pos, value=sig)
-                    for node, sig in zip(nodes, signatures)]
-        values = [ExprNodes.PyCFunctionNode.from_defnode(node, True)
-                              for node in nodes]
-        self.__signatures__ = ExprNodes.DictNode.from_pairs(self.pos,
-                                                            zip(keys, values))
-
-        self.specialized_pycfuncs = values
-        for pycfuncnode in values:
-            pycfuncnode.is_specialization = True
-
-    def generate_function_definitions(self, env, code):
-        if self.py_func:
-            self.py_func.pymethdef_required = True
-            self.fused_func_assignment.generate_function_definitions(env, code)
-
-        for stat in self.stats:
-            if isinstance(stat, FuncDefNode) and stat.entry.used:
-                code.mark_pos(stat.pos)
-                stat.generate_function_definitions(env, code)
-
-    def generate_execution_code(self, code):
-        import ExprNodes
-
-        for default in self.defaults:
-            if default is not None:
-                default.generate_evaluation_code(code)
-
-        if self.py_func:
-            self.defaults_tuple.generate_evaluation_code(code)
-            self.code_object.generate_evaluation_code(code)
-
-        for stat in self.stats:
-            code.mark_pos(stat.pos)
-            if isinstance(stat, ExprNodes.ExprNode):
-                stat.generate_evaluation_code(code)
-            elif not isinstance(stat, FuncDefNode) or stat.entry.used:
-                stat.generate_execution_code(code)
-
-        if self.__signatures__:
-            self.resulting_fused_function.generate_evaluation_code(code)
-
-            code.putln(
-                "((__pyx_FusedFunctionObject *) %s)->__signatures__ = %s;" %
-                                    (self.resulting_fused_function.result(),
-                                     self.__signatures__.result()))
-            code.put_giveref(self.__signatures__.result())
-
-            self.fused_func_assignment.generate_execution_code(code)
-
-            # Dispose of results
-            self.resulting_fused_function.generate_disposal_code(code)
-            self.defaults_tuple.generate_disposal_code(code)
-            self.code_object.generate_disposal_code(code)
-
-        for default in self.defaults:
-            if default is not None:
-                default.generate_disposal_code(code)
-
-    def annotate(self, code):
-        for stat in self.stats:
-            stat.annotate(code)
-
-
 class PyArgDeclNode(Node):
     # Argument which must be a Python object (used
     # for * and ** arguments).
@@ -3170,7 +2637,7 @@ class DefNode(FuncDefNode):
                 decorator.decorator.analyse_expressions(env)
 
     def needs_assignment_synthesis(self, env, code=None):
-        if self.is_wrapper or self.specialized_cpdefs:
+        if self.is_wrapper or self.specialized_cpdefs or self.entry.is_fused_specialized:
             return False
         if self.is_staticmethod:
             return True

Cython/Compiler/ParseTreeTransforms.py

@@ -1488,7 +1488,8 @@ if VALUE is not None:
 
                 return node
 
-            node = Nodes.FusedCFuncDefNode(node, env)
+            from Cython.Compiler import FusedNode
+            node = FusedNode.FusedCFuncDefNode(node, env)
 
             self.fused_function = node
             self.visitchildren(node)
@@ -1498,6 +1499,7 @@ if VALUE is not None:
                 # Create PyCFunction nodes for each specialization
                 node.stats.insert(0, node.py_func)
                 node.py_func = self.visit(node.py_func)
+                node.update_fused_defnode_entry(env)
                 pycfunc = ExprNodes.PyCFunctionNode.from_defnode(node.py_func,
                                                                  True)
                 pycfunc = ExprNodes.ProxyNode(pycfunc.coerce_to_temp(env))

Cython/Compiler/PyrexTypes.py

@@ -790,10 +790,9 @@ class BufferType(BaseType):
 
     def __str__(self):
         # avoid ', ', as fused functions split the signature string on ', '
+        cast_str = ''
         if self.cast:
             cast_str = ',cast=True'
-        else:
-            cast_str = ''
 
         return "%s[%s,ndim=%d%s]" % (self.base, self.dtype, self.ndim,
                                       cast_str)
@@ -2661,6 +2660,7 @@ def specialize_entry(entry, cname):
     """
     Specialize an entry of a copied fused function or method
     """
+    entry.is_fused_specialized = True
     entry.name = get_fused_cname(cname, entry.name)
 
     if entry.is_cmethod:

Cython/Compiler/Symtab.py

@@ -120,6 +120,8 @@ class Entry(object):
     # error_on_uninitialized      Have Control Flow issue an error when this entry is
     #                             used uninitialized
     # cf_used          boolean    Entry is used
+    # is_fused_specialized boolean Whether this entry of a cdef or def function
+    #                              is a specialization
 
     # TODO: utility_code and utility_code_definition serves the same purpose...
 
@@ -179,6 +181,7 @@ class Entry(object):
     prev_entry = None
     might_overflow = 0
     fused_cfunction = None
+    is_fused_specialized = False
     utility_code_definition = None
     in_with_gil_block = 0
     from_cython_utility_code = None
@@ -360,11 +363,11 @@ class Scope(object):
         # Return the module-level scope containing this scope.
         return self.outer_scope.builtin_scope()
 
-    def declare(self, name, cname, type, pos, visibility, shadow = 0):
+    def declare(self, name, cname, type, pos, visibility, shadow = 0, is_type = 0):
         # Create new entry, and add to dictionary if
         # name is not None. Reports a warning if already
         # declared.
-        if type.is_buffer and not isinstance(self, LocalScope):
+        if type.is_buffer and not isinstance(self, LocalScope): # and not is_type:
             error(pos, 'Buffer types only allowed as function local variables')
         if not self.in_cinclude and cname and re.match("^_[_A-Z]+$", cname):
             # See http://www.gnu.org/software/libc/manual/html_node/Reserved-Names.html#Reserved-Names
@@ -415,7 +418,8 @@ class Scope(object):
         # Add an entry for a type definition.
         if not cname:
             cname = name
-        entry = self.declare(name, cname, type, pos, visibility, shadow)
+        entry = self.declare(name, cname, type, pos, visibility, shadow,
+                             is_type=True)
         entry.is_type = 1
         entry.api = api
         if defining:

Cython/Compiler/TreeFragment.py

@@ -231,6 +231,12 @@ class TreeFragment(object):
                                    substitutions = nodes,
                                    temps = self.temps + temps, pos = pos)
 
+class SetPosTransform(VisitorTransform):
+    def __init__(self, pos):
+        super(SetPosTransform, self).__init__()
+        self.pos = pos
 
-
-
+    def visit_Node(self, node):
+        node.pos = self.pos
+        self.visitchildren(node)
+        return node

Cython/Compiler/UtilityCode.py

@@ -167,3 +167,11 @@ class CythonUtilityCode(Code.UtilityCodeBase):
                 dep.declare_in_scope(dest_scope)
 
         return original_scope
+
+def declare_declarations_in_scope(declaration_string, env, private_type=True,
+                                  *args, **kwargs):
+    """
+    Declare some declarations given as Cython code in declaration_string
+    in scope env.
+    """
+    CythonUtilityCode(declaration_string, *args, **kwargs).declare_in_scope(env)

Cython/Utility/CythonFunction.c

@@ -740,8 +740,6 @@ __pyx_FusedFunction_callfunction(PyObject *func, PyObject *args, PyObject *kw)
     int static_specialized = (cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD &&
                               !((__pyx_FusedFunctionObject *) func)->__signatures__);
 
-    //PyObject_Print(args, stdout, Py_PRINT_RAW);
-
     if (cyfunc->flags & __Pyx_CYFUNCTION_CCLASS && !static_specialized) {
         Py_ssize_t argc;
         PyObject *new_args;
@@ -827,8 +825,9 @@ __pyx_FusedFunction_call(PyObject *func, PyObject *args, PyObject *kw)
     }
 
     if (binding_func->__signatures__) {
-        PyObject *tup = PyTuple_Pack(3, binding_func->__signatures__, args,
-                                        kw == NULL ? Py_None : kw);
+        PyObject *tup = PyTuple_Pack(4, binding_func->__signatures__, args,
+                                        kw == NULL ? Py_None : kw,
+                                        binding_func->func.defaults_tuple);
         if (!tup)
             goto __pyx_err;
 

Cython/Utility/MemoryView.pyx

@@ -978,7 +978,7 @@ cdef memoryview_fromslice({{memviewslice_name}} *memviewslice,
     result.from_slice = memviewslice[0]
     __PYX_INC_MEMVIEW(memviewslice, 1)
 
-    result.from_object = <object> memviewslice.memview.obj
+    result.from_object = (<memoryview> memviewslice.memview).base
     result.typeinfo = memviewslice.memview.typeinfo
 
     result.view = memviewslice.memview.view

pyximport/pyximport.py

@@ -374,6 +374,18 @@ class PyxArgs(object):
 
 ##pyxargs=None   
 
+def _have_importers():
+    has_py_importer = False
+    has_pyx_importer = False
+    for importer in sys.meta_path:
+        if isinstance(importer, PyxImporter):
+            if isinstance(importer, PyImporter):
+                has_py_importer = True
+            else:
+                has_pyx_importer = True
+
+    return has_py_importer, has_pyx_importer
+
 def install(pyximport=True, pyimport=False, build_dir=None, build_in_temp=True,
             setup_args={}, reload_support=False,
             load_py_module_on_import_failure=False):
@@ -426,23 +438,32 @@ def install(pyximport=True, pyimport=False, build_dir=None, build_in_temp=True,
     pyxargs.reload_support = reload_support
     pyxargs.load_py_module_on_import_failure = load_py_module_on_import_failure
 
-    has_py_importer = False
-    has_pyx_importer = False
-    for importer in sys.meta_path:
-        if isinstance(importer, PyxImporter):
-            if isinstance(importer, PyImporter):
-                has_py_importer = True
-            else:
-                has_pyx_importer = True
+    has_py_importer, has_pyx_importer = _have_importers()
+    py_importer, pyx_importer = None, None
 
     if pyimport and not has_py_importer:
-        importer = PyImporter(pyxbuild_dir=build_dir)
-        sys.meta_path.insert(0, importer)
+        py_importer = PyImporter(pyxbuild_dir=build_dir)
+        sys.meta_path.insert(0, py_importer)
 
     if pyximport and not has_pyx_importer:
-        importer = PyxImporter(pyxbuild_dir=build_dir)
-        sys.meta_path.append(importer)
+        pyx_importer = PyxImporter(pyxbuild_dir=build_dir)
+        sys.meta_path.append(pyx_importer)
+
+    return py_importer, pyx_importer
 
+def uninstall(py_importer, pyx_importer):
+    """
+    Uninstall an import hook.
+    """
+    try:
+        sys.meta_path.remove(py_importer)
+    except ValueError:
+        pass
+
+    try:
+        sys.meta_path.remove(pyx_importer)
+    except ValueError:
+        pass
 
 # MAIN
 

runtests.py

@@ -1251,6 +1251,8 @@ def refactor_for_py3(distdir, cy3_dir):
                      recursive-include Cython *.py *.pyx *.pxd
                      recursive-include Cython/Debugger/Tests *
                      recursive-include Cython/Utility *
+                     recursive-exclude pyximport test
+                     include pyximport/*.py
                      include runtests.py
                      include cython.py
                      ''')

setup.py

@@ -112,6 +112,7 @@ def compile_cython_modules(profile=False, compile_more=False, cython_with_refnan
                         "Cython.Compiler.FlowControl",
                         "Cython.Compiler.Code",
                         "Cython.Runtime.refnanny",
+                        # "Cython.Compiler.FusedNode",
                         ]
     if compile_more:
         compiled_modules.extend([

tests/run/cyfunction_defaults.pyx

@@ -107,3 +107,27 @@ def test_defaults_fused(cython.floating arg1, cython.floating arg2 = counter2())
     (2.0,)
     """
     print arg1, arg2
+
+funcs = []
+for i in range(10):
+    def defaults_fused(cython.floating a, cython.floating b = i):
+        return a, b
+    funcs.append(defaults_fused)
+
+def test_dynamic_defaults_fused():
+    """
+    >>> test_dynamic_defaults_fused()
+    i 0 func result (1.0, 0.0) defaults (0,)
+    i 1 func result (1.0, 1.0) defaults (1,)
+    i 2 func result (1.0, 2.0) defaults (2,)
+    i 3 func result (1.0, 3.0) defaults (3,)
+    i 4 func result (1.0, 4.0) defaults (4,)
+    i 5 func result (1.0, 5.0) defaults (5,)
+    i 6 func result (1.0, 6.0) defaults (6,)
+    i 7 func result (1.0, 7.0) defaults (7,)
+    i 8 func result (1.0, 8.0) defaults (8,)
+    i 9 func result (1.0, 9.0) defaults (9,)
+    """
+    for i, f in enumerate(funcs):
+        print "i", i, "func result", f(1.0), "defaults", get_defaults(f)
+

tests/run/numpy_test.pyx

@@ -4,6 +4,8 @@
 cimport numpy as np
 cimport cython
 
+from libc.stdlib cimport malloc
+
 def little_endian():
     cdef int endian_detector = 1
     return (<char*>&endian_detector)[0] != 0
@@ -503,19 +505,28 @@ def test_point_record():
         test[i].y = -i
     print repr(test).replace('<', '!').replace('>', '!')
 
-def test_fused_ndarray_dtype(np.ndarray[cython.floating, ndim=1] a):
+# Test fused np.ndarray dtypes and runtime dispatch
+def test_fused_ndarray_floating_dtype(np.ndarray[cython.floating, ndim=1] a):
     """
     >>> import cython
-    >>> sorted(test_fused_ndarray_dtype.__signatures__)
+    >>> sorted(test_fused_ndarray_floating_dtype.__signatures__)
     ['double', 'float']
-    >>> test_fused_ndarray_dtype[cython.double](np.arange(10, dtype=np.float64))
+
+
+    >>> test_fused_ndarray_floating_dtype[cython.double](np.arange(10, dtype=np.float64))
     ndarray[double,ndim=1] ndarray[double,ndim=1] 5.0 6.0
-    >>> test_fused_ndarray_dtype[cython.float](np.arange(10, dtype=np.float32))
+    >>> test_fused_ndarray_floating_dtype(np.arange(10, dtype=np.float64))
+    ndarray[double,ndim=1] ndarray[double,ndim=1] 5.0 6.0
+
+    >>> test_fused_ndarray_floating_dtype[cython.float](np.arange(10, dtype=np.float32))
+    ndarray[float,ndim=1] ndarray[float,ndim=1] 5.0 6.0
+    >>> test_fused_ndarray_floating_dtype(np.arange(10, dtype=np.float32))
     ndarray[float,ndim=1] ndarray[float,ndim=1] 5.0 6.0
     """
     cdef np.ndarray[cython.floating, ndim=1] b = a
     print cython.typeof(a), cython.typeof(b), a[5], b[6]
 
+
 double_array = np.linspace(0, 1, 100)
 int32_array = np.arange(100, dtype=np.int32)
 
@@ -537,10 +548,8 @@ def test_fused_external(np.ndarray[fused_external, ndim=1] a):
     >>> test_fused_external["int32_t"](int32_array)
     int32
 
-    >>> test_fused_external(np.arange(100)) # fix in next release
-    Traceback (most recent call last):
-        ...
-    TypeError: No matching signature found
+    >>> test_fused_external(np.arange(100))
+    int64
     """
     print a.dtype
 
@@ -568,4 +577,245 @@ def test_fused_cpdef_buffers():
     cdef np.ndarray[np.int32_t] typed_array = int32_array
     _fused_cpdef_buffers(typed_array)
 
+def test_fused_ndarray_integral_dtype(np.ndarray[cython.integral, ndim=1] a):
+    """
+    >>> import cython
+    >>> sorted(test_fused_ndarray_integral_dtype.__signatures__)
+    ['int', 'long', 'short']
+
+    >>> test_fused_ndarray_integral_dtype[cython.int](np.arange(10, dtype=np.dtype('i')))
+    ndarray[int,ndim=1] ndarray[int,ndim=1] 5 6
+    >>> test_fused_ndarray_integral_dtype(np.arange(10, dtype=np.dtype('i')))
+    ndarray[int,ndim=1] ndarray[int,ndim=1] 5 6
+
+    >>> test_fused_ndarray_integral_dtype[cython.long](np.arange(10, dtype=np.long))
+    ndarray[long,ndim=1] ndarray[long,ndim=1] 5 6
+    >>> test_fused_ndarray_integral_dtype(np.arange(10, dtype=np.long))
+    ndarray[long,ndim=1] ndarray[long,ndim=1] 5 6
+    """
+    cdef np.ndarray[cython.integral, ndim=1] b = a
+    print cython.typeof(a), cython.typeof(b), a[5], b[6]
+
+cdef fused fused_dtype:
+    float complex
+    double complex
+    object
+
+def test_fused_ndarray_other_dtypes(np.ndarray[fused_dtype, ndim=1] a):
+    """
+    >>> import cython
+    >>> sorted(test_fused_ndarray_other_dtypes.__signatures__)
+    ['double complex', 'float complex', 'object']
+    >>> test_fused_ndarray_other_dtypes(np.arange(10, dtype=np.complex64))
+    ndarray[float complex,ndim=1] ndarray[float complex,ndim=1] (5+0j) (6+0j)
+    >>> test_fused_ndarray_other_dtypes(np.arange(10, dtype=np.complex128))
+    ndarray[double complex,ndim=1] ndarray[double complex,ndim=1] (5+0j) (6+0j)
+    >>> test_fused_ndarray_other_dtypes(np.arange(10, dtype=np.object))
+    ndarray[Python object,ndim=1] ndarray[Python object,ndim=1] 5 6
+    """
+    cdef np.ndarray[fused_dtype, ndim=1] b = a
+    print cython.typeof(a), cython.typeof(b), a[5], b[6]
+
+
+# Test fusing the array types together and runtime dispatch
+cdef struct Foo:
+    int a
+    float b
+
+cdef fused fused_FooArray:
+    np.ndarray[Foo, ndim=1]
+
+cdef fused fused_ndarray:
+    np.ndarray[float, ndim=1]
+    np.ndarray[double, ndim=1]
+    np.ndarray[Foo, ndim=1]
+
+def get_Foo_array():
+    cdef Foo[:] result = <Foo[:10]> malloc(sizeof(Foo) * 10)
+    result[5].b = 9.0
+    return np.asarray(result)
+
+def test_fused_ndarray(fused_ndarray a):
+    """
+    >>> import cython
+    >>> sorted(test_fused_ndarray.__signatures__)
+    ['ndarray[Foo,ndim=1]', 'ndarray[double,ndim=1]', 'ndarray[float,ndim=1]']
+
+    >>> test_fused_ndarray(get_Foo_array())
+    ndarray[Foo,ndim=1] ndarray[Foo,ndim=1]
+    9.0
+    >>> test_fused_ndarray(np.arange(10, dtype=np.float64))
+    ndarray[double,ndim=1] ndarray[double,ndim=1]
+    5.0
+    >>> test_fused_ndarray(np.arange(10, dtype=np.float32))
+    ndarray[float,ndim=1] ndarray[float,ndim=1]
+    5.0
+    """
+    cdef fused_ndarray b = a
+    print cython.typeof(a), cython.typeof(b)
+
+    if fused_ndarray in fused_FooArray:
+        print b[5].b
+    else:
+        print b[5]
+
+cpdef test_fused_cpdef_ndarray(fused_ndarray a):
+    """
+    >>> import cython
+    >>> sorted(test_fused_cpdef_ndarray.__signatures__)
+    ['ndarray[Foo,ndim=1]', 'ndarray[double,ndim=1]', 'ndarray[float,ndim=1]']
+
+    >>> test_fused_cpdef_ndarray(get_Foo_array())
+    ndarray[Foo,ndim=1] ndarray[Foo,ndim=1]
+    9.0
+    >>> test_fused_cpdef_ndarray(np.arange(10, dtype=np.float64))
+    ndarray[double,ndim=1] ndarray[double,ndim=1]
+    5.0
+    >>> test_fused_cpdef_ndarray(np.arange(10, dtype=np.float32))
+    ndarray[float,ndim=1] ndarray[float,ndim=1]
+    5.0
+    """
+    cdef fused_ndarray b = a
+    print cython.typeof(a), cython.typeof(b)
+
+    if fused_ndarray in fused_FooArray:
+        print b[5].b
+    else:
+        print b[5]
+
+def test_fused_cpdef_ndarray_cdef_call():
+    """
+    >>> test_fused_cpdef_ndarray_cdef_call()
+    ndarray[Foo,ndim=1] ndarray[Foo,ndim=1]
+    9.0
+    """
+    cdef np.ndarray[Foo, ndim=1] foo_array = get_Foo_array()
+    test_fused_cpdef_ndarray(foo_array)
+
+cdef fused int_type:
+    np.int32_t
+    np.int64_t
+
+float64_array = np.arange(10, dtype=np.float64)
+float32_array = np.arange(10, dtype=np.float32)
+int32_array = np.arange(10, dtype=np.int32)
+int64_array = np.arange(10, dtype=np.int64)
+
+def test_dispatch_non_clashing_declarations_repeating_types(np.ndarray[cython.floating] a1,
+                                                            np.ndarray[int_type] a2,
+                                                            np.ndarray[cython.floating] a3,
+                                                            np.ndarray[int_type] a4):
+    """
+    >>> test_dispatch_non_clashing_declarations_repeating_types(float64_array, int32_array, float64_array, int32_array)
+    1.0 2 3.0 4
+    >>> test_dispatch_non_clashing_declarations_repeating_types(float64_array, int64_array, float64_array, int64_array)
+    1.0 2 3.0 4
+    >>> test_dispatch_non_clashing_declarations_repeating_types(float64_array, int32_array, float64_array, int64_array)
+    Traceback (most recent call last):
+       ...
+    TypeError: No matching signature found
+    """
+    print a1[1], a2[2], a3[3], a4[4]
+
+ctypedef np.int32_t typedeffed_type
+
+cdef fused typedeffed_fused_type:
+    typedeffed_type
+    int
+    long
+
+def test_dispatch_typedef(np.ndarray[typedeffed_fused_type] a):
+    """
+    >>> test_dispatch_typedef(int32_array)
+    5
+    """
+    print a[5]
+
+
+cdef extern from "types.h":
+    ctypedef char actually_long_t
+
+cdef fused confusing_fused_typedef:
+    actually_long_t
+    int
+    unsigned long
+    double complex
+    unsigned char
+    signed char
+
+def test_dispatch_external_typedef(np.ndarray[confusing_fused_typedef] a):
+    """
+    >>> test_dispatch_external_typedef(np.arange(-5, 5, dtype=np.long))
+    -2
+    """
+    print a[3]
+
+# test fused memoryview slices
+cdef fused memslice_fused_dtype:
+    float
+    double
+    int
+    long
+    float complex
+    double complex
+    object
+
+def test_fused_memslice_other_dtypes(memslice_fused_dtype[:] a):
+    """
+    >>> import cython
+    >>> sorted(test_fused_memslice_other_dtypes.__signatures__)
+    ['double', 'double complex', 'float', 'float complex', 'int', 'long', 'object']
+    >>> test_fused_memslice_other_dtypes(np.arange(10, dtype=np.complex64))
+    float complex[:] float complex[:] (5+0j) (6+0j)
+    >>> test_fused_memslice_other_dtypes(np.arange(10, dtype=np.complex128))
+    double complex[:] double complex[:] (5+0j) (6+0j)
+    >>> test_fused_memslice_other_dtypes(np.arange(10, dtype=np.float32))
+    float[:] float[:] 5.0 6.0
+    >>> test_fused_memslice_other_dtypes(np.arange(10, dtype=np.dtype('i')))
+    int[:] int[:] 5 6
+    >>> test_fused_memslice_other_dtypes(np.arange(10, dtype=np.object))
+    object[:] object[:] 5 6
+    """
+    cdef memslice_fused_dtype[:] b = a
+    print cython.typeof(a), cython.typeof(b), a[5], b[6]
+
+cdef fused memslice_fused:
+    float[:]
+    double[:]
+    int[:]
+    long[:]
+    float complex[:]
+    double complex[:]
+    object[:]
+
+def test_fused_memslice(memslice_fused a):
+    """
+    >>> import cython
+    >>> sorted(test_fused_memslice.__signatures__)
+    ['double complex[:]', 'double[:]', 'float complex[:]', 'float[:]', 'int[:]', 'long[:]', 'object[:]']
+    >>> test_fused_memslice(np.arange(10, dtype=np.complex64))
+    float complex[:] float complex[:] (5+0j) (6+0j)
+    >>> test_fused_memslice(np.arange(10, dtype=np.complex128))
+    double complex[:] double complex[:] (5+0j) (6+0j)
+    >>> test_fused_memslice(np.arange(10, dtype=np.float32))
+    float[:] float[:] 5.0 6.0
+    >>> test_fused_memslice(np.arange(10, dtype=np.dtype('i')))
+    int[:] int[:] 5 6
+    >>> test_fused_memslice(np.arange(10, dtype=np.object))
+    object[:] object[:] 5 6
+    """
+    cdef memslice_fused b = a
+    print cython.typeof(a), cython.typeof(b), a[5], b[6]
+
+def test_dispatch_memoryview_object():
+    """
+    >>> test_dispatch_memoryview_object()
+    int[:] int[:] 5 6
+    """
+    cdef int[:] m = np.arange(10, dtype=np.dtype('i'))
+    cdef int[:] m2 = m
+    cdef int[:] m3 = <object> m
+    test_fused_memslice(m3)
+
+
 include "numpy_common.pxi"