Infer variable as pyobject when del-ed, fix #768

Cython/Compiler/FlowControl.py

@@ -313,6 +313,12 @@ class NameAssignment(object):
     def __repr__(self):
         return '%s(entry=%r)' % (self.__class__.__name__, self.entry)
 
+    def infer_type(self, scope):
+        return self.rhs.infer_type(scope)
+
+    def type_dependencies(self, scope):
+        return self.rhs.type_dependencies(scope)
+
 
 class Argument(NameAssignment):
     def __init__(self, lhs, rhs, entry):
@@ -325,6 +331,13 @@ class NameDeletion(NameAssignment):
         NameAssignment.__init__(self, lhs, lhs, entry)
         self.is_deletion = True
 
+    def infer_type(self, scope):
+        inferred_type = self.rhs.infer_type(scope)
+        if (not inferred_type.is_pyobject and
+            inferred_type.can_coerce_to_pyobject(scope)):
+            return py_object_type
+        return inferred_type
+
 
 class Uninitialized(object):
     pass

Cython/Compiler/TypeInference.py

@@ -363,7 +363,7 @@ class SimpleAssignmentTypeInferer(object):
                     continue
                 all = set()
                 for assmt in entry.cf_assignments:
-                    all.update(assmt.rhs.type_dependencies(scope))
+                    all.update(assmt.type_dependencies(scope))
                 if all:
                     dependancies_by_entry[entry] = all
                     for dep in all:
@@ -401,12 +401,12 @@ class SimpleAssignmentTypeInferer(object):
             # Deal with simple circular dependancies...
             for entry, deps in dependancies_by_entry.items():
                 if len(deps) == 1 and deps == set([entry]):
-                    types = [assmt.rhs.infer_type(scope)
+                    types = [assmt.infer_type(scope)
                              for assmt in entry.cf_assignments
-                             if assmt.rhs.type_dependencies(scope) == ()]
+                             if assmt.type_dependencies(scope) == ()]
                     if types:
                         entry.type = spanning_type(types, entry.might_overflow)
-                        types = [assmt.rhs.infer_type(scope)
+                        types = [assmt.infer_type(scope)
                                  for assmt in entry.cf_assignments]
                         entry.type = spanning_type(types, entry.might_overflow) # might be wider...
                         resolve_dependancy(entry)

tests/run/type_inference_T768.pyx

+# mode: run
+# ticket: 768
+from cython cimport typeof
+
+def type_inference_del_int():
+    """
+    >>> type_inference_del_int()
+    'Python object'
+    """
+    x = 1
+    del x
+    return typeof(x)
+
+def type_inference_del_dict():
+    """
+    >>> type_inference_del_dict()
+    'dict object'
+    """
+    x = {}
+    del x
+    return typeof(x)

tests/run/type_inference_T768_cpp.pyx

+# mode: run
+# tag: cpp
+# ticket: 768
+from cython cimport typeof
+
+cdef extern from "shapes.h" namespace "shapes":
+    cdef cppclass Shape:
+        float area()
+
+    cdef cppclass Circle(Shape):
+        int radius
+        Circle(int)
+
+def type_inference_del_cpp():
+    """
+    >>> type_inference_del_cpp()
+    'Circle *'
+    """
+    x = new Circle(10)
+    del x
+    return typeof(x)