Fix exception in is_copy_constructor() when a typedef was passed to the constructor.

See issue #27. is_copy_constructor() will now return False in this case, instead of failing.

Author: iMichka

docs/history.rst

@@ -11,6 +11,13 @@ to python 3 (keeping it compatible with python 2).
 In Mai 2014, Michka Popoff and the Insight Software Consortium revived pygccxml
 by setting up a git repositery on github, hosted along with gccxml.
 
+Version 1.7.2 (unreleased)
+--------------------------
+
+1. Fix exception in is_copy_constructor() when the constructor's argument was
+   a typedef. is_copy_constructor() will now return False instead of failing.
+   See issue #27.
+
 Version 1.7.1
 -------------
 

pygccxml/declarations/calldef.py

@@ -738,7 +738,7 @@ def __str__(self):
     def is_copy_constructor(self):
         """
         Returns True if described declaration is copy constructor,
-        otherwise False
+        otherwise False.
 
         """
 
@@ -753,6 +753,17 @@ def is_copy_constructor(self):
         # We have only one argument, get it
         arg = args[0]
 
+        if not isinstance(arg.type, cpptypes.compound_t):
+            # An argument of type declarated_t (a typedef) could be passed to
+            # the constructor; and it could be a reference.
+            # But in c++ you can NOT write :
+            #    "typedef class MyClass { MyClass(const MyClass & arg) {} }"
+            # If the argument is a typedef, this is not a copy constructor.
+            # See the hierarchy of declarated_t and coumpound_t. They both
+            # inherit from type_t but are not related so we can discriminate
+            # between them.
+            return False
+
         # The argument needs to be passed by reference in a copy constructor
         if not type_traits.is_reference(arg.type):
             return False
@@ -764,8 +775,14 @@ def is_copy_constructor(self):
         un_aliased = type_traits.remove_alias(arg.type.base)
         # un_aliased now refers to const_t instance
         if not isinstance(un_aliased.base, cpptypes.declarated_t):
+            # We are looking for a declaration
+            # If "class MyClass { MyClass(const int & arg) {} }" is used,
+            # this is not copy constructor, so we return False here.
+            # -> un_aliased.base == cpptypes.int_t (!= cpptypes.declarated_t)
             return False
 
+        # Final check: compare the parent (the class declaration for example)
+        # with the declaration of the type passed as argument.
         return id(un_aliased.base.declaration) == id(self.parent)
 
     @property

unittests/data/test_copy_constructor.hpp

@@ -0,0 +1,21 @@
+// Copyright 2014-2016 Insight Software Consortium.
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+typedef const int & myvar;
+
+class test
+{
+    public:
+        // The copy constructor
+        test(const test & t0){};
+
+        // A constructor
+        test(const float & t0){};
+
+        // A constructor with a typedef
+        test(myvar t0){};
+};
+
+// An empty class; C++ will automatically create a copy constructor
+class test2 {};

unittests/test_copy_constructor.py

@@ -0,0 +1,65 @@
+# Copyright 2014-2016 Insight Software Consortium.
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+
+import unittest
+import parser_test_case
+
+from pygccxml import parser
+from pygccxml import declarations
+
+
+class tester_t(parser_test_case.parser_test_case_t):
+
+    def __init__(self, *args):
+        parser_test_case.parser_test_case_t.__init__(self, *args)
+        self.header = "test_copy_constructor.hpp"
+
+    def setUp(self):
+        decls = parser.parse([self.header], self.config)
+        self.global_ns = declarations.get_global_namespace(decls)
+
+    def test(self):
+        """
+        Check the is_copy_constructor method.
+
+        This fails when using CastXML, see issue #27.
+
+        """
+
+        tclass = self.global_ns.class_("test")
+        ctors = []
+        for decl in tclass.declarations:
+            if isinstance(decl, declarations.calldef.constructor_t):
+                ctors.append(decl)
+
+        # test::test(test const & t0) [copy constructor]
+        self.assertTrue(ctors[0].is_copy_constructor)
+        # test::test(float const & t0) [constructor]
+        self.assertFalse(ctors[1].is_copy_constructor)
+        # test::test(myvar t0) [constructor]
+        self.assertFalse(ctors[2].is_copy_constructor)
+
+        t2class = self.global_ns.class_("test2")
+        ctors = []
+        for decl in t2class.declarations:
+            if isinstance(decl, declarations.calldef.constructor_t):
+                ctors.append(decl)
+
+        # test2::test2() [constructor]
+        self.assertFalse(ctors[0].is_copy_constructor)
+        # test2::test2(test2 const & arg0) [copy constructor]
+        self.assertTrue(ctors[1].is_copy_constructor)
+
+
+def create_suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(tester_t))
+    return suite
+
+
+def run_suite():
+    unittest.TextTestRunner(verbosity=2).run(create_suite())
+
+if __name__ == "__main__":
+    run_suite()