.

Cython/Compiler/ExprNodes.py

@@ -7462,7 +7462,7 @@ class SequenceNode(ExprNode):
                 ', '.join(arg.py_result() for arg in self.args),
                 code.error_goto_if_null(target, self.pos)))
             code.put_gotref(target)
-        elif self.type.is_ctuple:
+        elif self.type.is_ctuple:   # NOTE
             for i, arg in enumerate(self.args):
                 code.putln("%s.f%s = %s;" % (
                     target, i, arg.result()))

Cython/Compiler/Pipeline.py

@@ -213,7 +213,7 @@ def create_pipeline(context, mode, exclude_classes=()):
 
         #PrintTree(),
         AnalyseExpressionsTransform(context),
-        #PrintTree(),
+        PrintTree(),
 
         FindInvalidUseOfFusedTypes(context),
         ExpandInplaceOperators(context),

Cython/Compiler/PyrexTypes.py

@@ -3579,6 +3579,25 @@ class CppClassType(CType):
             return True
         return False
 
+    # FIXME wrong place: for coercion not only type is needed - but note (e.g.
+    # actual variable name)
+    def coerce_to(self, dst_type, env):
+        if self.cname == "std::pair" and dst_type.is_ctuple:
+            node = self._coerce_pair_to_ctuple(dst_type, env)
+            if node is not None:
+                return node
+
+        return super(CppClassType, self).coerce_to(dst_type, env)
+
+    # std::pair[X,Y] -> ctuple(X,Y)
+    def _coerce_pair_to_ctuple(self, dst_type, env): # -> node | None
+        if not (len(self.templates) == len(dst_type.components) == 2):
+            return None
+        for (c_src, c_dst) in zip(self.templates, dst_type.components):
+            if not c_src.same_as(c_dst):
+                return None
+        # can be converted
+
     def create_from_py_utility_code(self, env):
         if self.from_py_function is not None:
             return True
@@ -4062,6 +4081,8 @@ class CTupleType(CType):
         env.use_utility_code(self._convert_from_py_code)
         return True
 
+    # XXX kill
+    """
     def assignable_from_resolved_type(self, src_type):
         # (X,Y) can be assigned from std::pair[X,Y]
         if src_type.is_cpp_class and src_type.cname == "std::pair":
@@ -4070,21 +4091,11 @@ class CTupleType(CType):
             for (c_dst, c_src) in zip(self.components, src_type.templates):
                 if not c_dst.same_as(c_src):
                     return False
-            return True
-
-            """
-            print
-            #from Cython.Compiler.Pipeline import dumptree
-            #dumptree(src_type)
-            print src_type
-            print src_type.name
-            print src_type.cname
-            print src_type.templates
-            print
-            return 1    # XXX check types are the same
-            """
+            #return True
+            return False
 
         return super(CTupleType, self).assignable_from_resolved_type(src_type)
+    """
 
 
 def c_tuple_type(components):