merge

Cython/Compiler/ModuleNode.py

@@ -481,6 +481,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         typecode = globalstate['type_declarations']
         typecode.putln("")
         typecode.putln("/*--- Type declarations ---*/")
+        # This is to work around the fact that array.h isn't part of the C-API,
+        # but we need to declare it earlier than utility code.
+        if 'cpython.array' in [m.qualified_name for m in modules]:
+            typecode.putln('#ifndef _ARRAYARRAY_H')
+            typecode.putln('struct arrayobject;')
+            typecode.putln('typedef struct arrayobject arrayobject;')
+            typecode.putln('#endif')
         vtab_list, vtabslot_list = self.sort_type_hierarchy(modules, env)
         self.generate_type_definitions(
             env, modules, vtab_list, vtabslot_list, typecode)

Cython/Compiler/Nodes.py

@@ -838,9 +838,21 @@ class CSimpleBaseTypeNode(CBaseTypeNode):
                 type = py_object_type
         else:
             if self.module_path:
-                scope = env.find_imported_module(self.module_path, self.pos)
-                if scope:
-                    scope.fused_to_specific = env.fused_to_specific
+                # Maybe it's a nested C++ class.
+                scope = env
+                for item in self.module_path:
+                    entry = scope.lookup(item)
+                    if entry.is_cpp_class:
+                        scope = entry.type.scope
+                    else:
+                        scope = None
+                        break
+                
+                if scope is None:
+                    # Maybe it's a cimport.
+                    scope = env.find_imported_module(self.module_path, self.pos)
+                    if scope:
+                        scope.fused_to_specific = env.fused_to_specific
             else:
                 scope = env
 

Cython/Utility/arrayarray.h

@@ -13,7 +13,11 @@
 #ifndef _ARRAYARRAY_H
 #define _ARRAYARRAY_H
 
-struct arrayobject; /* Forward */
+// These two forward declarations are explicitly handled in the type
+// declaration code, as including them here is too late for cython-defined
+// types to use them.
+// struct arrayobject;
+// typedef struct arrayobject arrayobject;
 
 // All possible arraydescr values are defined in the vector "descriptors"
 // below.  That's defined later because the appropriate get and set
@@ -29,7 +33,7 @@ typedef struct arraydescr {
 } arraydescr;
 
 
-typedef struct arrayobject {
+struct arrayobject {
     PyObject_HEAD
     Py_ssize_t ob_size;
     union {
@@ -54,8 +58,7 @@ typedef struct arrayobject {
 #if PY_VERSION_HEX >= 0x03000000
         int ob_exports;  /* Number of exported buffers */
 #endif
-} arrayobject;
-
+};
 
 #ifndef NO_NEWARRAY_INLINE
 //  fast creation of a new array

tests/run/array_cimport.srctree

+PYTHON setup.py build_ext --inplace
+PYTHON -c "import ttt"
+
+######## setup.py ########
+
+from Cython.Build.Dependencies import cythonize
+from distutils.core import setup
+
+setup(
+  ext_modules = cythonize("*.pyx"),
+)
+
+
+######## tt.pxd ########
+
+from cpython.array cimport array
+
+cdef class Foo:
+    cdef array obj
+
+######## tt.pyx ########
+
+cdef class Foo:
+    def __init__(self, data):
+        self.obj = data
+
+######## ttt.pyx ########
+
+from array import array
+from cpython.array cimport array
+from tt cimport Foo
+
+cdef array a = array('i', [1,2,3])
+cdef Foo x
+print a.data.as_ints[0]
+x = Foo(a)
+print x.obj.data.as_ints[0]

tests/run/cpp_nested_classes.pyx

+# tag: cpp
+
+cdef extern from "cpp_nested_classes_support.cpp":
+    cdef cppclass A:
+        cppclass B:
+            int square(int)
+            cppclass C:
+                int cube(int)
+        B* createB()
+
+def test():
+    """
+    >>> test()
+    """
+    cdef A a
+    cdef A.B b
+    assert b.square(3) == 9
+    cdef A.B.C c
+    assert c.cube(3) == 27
+    
+    cdef A.B *b_ptr = a.createB()
+    assert b_ptr.square(4) == 16
+    del b_ptr

tests/run/cpp_nested_classes_support.cpp

+class A {
+public:
+  class B {
+  public:
+    int square(int x) { return x * x; }
+    class C {
+        public:
+        int cube(int x) { return x * x * x; }
+    };
+  };
+  B* createB() {
+    return new B();
+  }
+};