Merge branch 'hotfix/v1.9.1'

Author: iMichka

CHANGELOG.md

@@ -1,6 +1,20 @@
 Changes
 =======
 
+Version 1.9.1
+-------------
+
+1. Fix bug in the ```find_noncopyable_vars``` method which wrongly returned
+   member variables of pointer type (#84)
+
+2. Fix bug in the ```smart_pointer_traits.value_type``` and
+   ```auto_pointer_traits.value_type``` methods which didn't find the expected
+   ```value_type``` declaration (#85)
+
+3. Fix bug in the ```smart_pointer_traits.is_smart_pointer``` and
+   ```auto_pointer_traits.is_smart_pointer``` methods which didn't properly
+   work (#85)
+
 Version 1.9.0
 -------------
 

pygccxml/__init__.py

@@ -41,4 +41,4 @@
 # TODO:
 # 1. Add "explicit" property for constructors
 
-__version__ = '1.9.0'
+__version__ = '1.9.1'

pygccxml/declarations/smart_pointer_traits.py

@@ -9,6 +9,7 @@
 from . import class_declaration_traits
 from . import class_traits
 from . import traits_impl_details
+from . import runtime_errors
 
 
 class internal_type_traits(object):
@@ -17,8 +18,8 @@ class internal_type_traits(object):
     # TODO: add exists function
     @staticmethod
     def get_by_name(type_, name):
-        if class_declaration_traits.is_my_case(type_):
-            cls = class_traits.declaration_class(type_)
+        if class_traits.is_my_case(type_):
+            cls = class_traits.get_declaration(type_)
             return type_traits.remove_declarated(
                 cls.typedef(name, recursive=False).decl_type)
         elif class_declaration_traits.is_my_case(type_):
@@ -72,7 +73,10 @@ def value_type(type_):
                 'Type "%s" is not an instantiation of \
                 boost::shared_ptr or std::shared_ptr' %
                 type_.decl_string)
-        return internal_type_traits.get_by_name(type_, "value_type")
+        try:
+            return internal_type_traits.get_by_name(type_, "element_type")
+        except runtime_errors.declaration_not_found_t:
+            return _search_in_bases(type_)
 
 
 class auto_ptr_traits(object):
@@ -103,4 +107,23 @@ def value_type(type_):
             raise TypeError(
                 'Type "%s" is not instantiation of std::auto_ptr' %
                 type_.decl_string)
-        return internal_type_traits.get_by_name(type_, "element_type")
+        try:
+            return internal_type_traits.get_by_name(type_, "element_type")
+        except runtime_errors.declaration_not_found_t:
+            return _search_in_bases(type_)
+
+
+def _search_in_bases(type_):
+    """Implementation detail."""
+    found = False
+    for base_type in type_.declaration.bases:
+        try:
+            found = internal_type_traits.get_by_name(
+                base_type.related_class, "element_type")
+        except runtime_errors.declaration_not_found_t:
+            pass
+        if found:
+            return found
+    raise RuntimeError(
+        ("Unable to find 'element_type' declaration '%s'"
+         "in type '%s'.") % type_.decl_string)

pygccxml/declarations/type_traits_classes.py

@@ -152,7 +152,7 @@ def find_copy_constructor(type_):
         return None
 
 
-def find_noncopyable_vars(type_, already_visited_cls_vars=None):
+def find_noncopyable_vars(class_type, already_visited_cls_vars=None):
     """
     Returns list of all `noncopyable` variables.
 
@@ -161,18 +161,19 @@ def find_noncopyable_vars(type_, already_visited_cls_vars=None):
     whatever variables pointing to classes have been found.
 
     Args:
-        type_ (declarations.class_t): the class to be searched.
+        class_type (declarations.class_t): the class to be searched.
         already_visited_cls_vars (list): optional list of vars that should not
             be checked a second time, to prevent infinite recursions.
 
     Returns:
         list: list of all `noncopyable` variables.
 
     """
-    assert isinstance(type_, class_declaration.class_t)
+
+    assert isinstance(class_type, class_declaration.class_t)
 
     logger = utils.loggers.cxx_parser
-    mvars = type_.variables(
+    mvars = class_type.variables(
         lambda v: not v.type_qualifiers.has_static,
         recursive=False,
         allow_empty=True)
@@ -187,25 +188,28 @@ def find_noncopyable_vars(type_, already_visited_cls_vars=None):
 
     for mvar in mvars:
 
-        type_ = type_traits.remove_reference(mvar.decl_type)
+        var_type = type_traits.remove_reference(mvar.decl_type)
 
-        if type_traits.is_const(type_):
-            no_const = type_traits.remove_const(type_)
+        if type_traits.is_const(var_type):
+            no_const = type_traits.remove_const(var_type)
             if type_traits.is_fundamental(no_const) or is_enum(no_const):
                 logger.debug(
                     (message + "- fundamental or enum"),
-                    type_.decl_string)
+                    var_type.decl_string)
                 noncopyable_vars.append(mvar)
             if is_class(no_const):
-                logger.debug((message + " - class"), type_.decl_string)
+                logger.debug((message + " - class"), var_type.decl_string)
                 noncopyable_vars.append(mvar)
             if type_traits.is_array(no_const):
-                logger.debug((message + " - array"), type_.decl_string)
+                logger.debug((message + " - array"), var_type.decl_string)
                 noncopyable_vars.append(mvar)
 
-        if class_traits.is_my_case(type_):
+        if type_traits.is_pointer(var_type):
+            continue
+
+        if class_traits.is_my_case(var_type):
 
-            cls = class_traits.get_declaration(type_)
+            cls = class_traits.get_declaration(var_type)
 
             # Exclude classes that have already been visited.
             if cls in already_visited_cls_vars:
@@ -215,12 +219,12 @@ def find_noncopyable_vars(type_, already_visited_cls_vars=None):
             if is_noncopyable(cls, already_visited_cls_vars):
                 logger.debug(
                     (message + " - class that is not copyable"),
-                    type_.decl_string)
+                    var_type.decl_string)
                 noncopyable_vars.append(mvar)
 
     logger.debug((
         "__contains_noncopyable_mem_var - %s - FALSE - doesn't " +
-        "contain noncopyable members"), type_.decl_string)
+        "contain noncopyable members"), class_type.decl_string)
 
     return noncopyable_vars
 

unittests/data/find_noncopyable_vars.hpp

@@ -0,0 +1,13 @@
+// Copyright 2014-2017 Insight Software Consortium.
+// Copyright 2004-2009 Roman Yakovenko.
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+struct abstract{
+  virtual void do_smth() = 0;
+};
+
+struct holder{
+  abstract* ptr1;
+  abstract* const ptr2;
+};

unittests/test_all.py

@@ -82,6 +82,7 @@
 from . import test_castxml_wrong_epic
 from . import test_elaborated_types
 from . import test_order
+from . import test_find_noncopyable_vars
 
 testers = [
     # , demangled_tester # failing right now
@@ -154,7 +155,8 @@
     test_non_copyable_recursive,
     test_castxml_wrong_epic,
     test_elaborated_types,
-    test_order
+    test_order,
+    test_find_noncopyable_vars
 ]
 
 if platform.system() != 'Windows':

unittests/test_find_noncopyable_vars.py

@@ -0,0 +1,49 @@
+# Copyright 2014-2017 Insight Software Consortium.
+# Copyright 2004-2009 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+
+import unittest
+
+from . import parser_test_case
+
+from pygccxml import parser
+from pygccxml import declarations
+
+
+class Test(parser_test_case.parser_test_case_t):
+
+    def __init__(self, *args):
+        parser_test_case.parser_test_case_t.__init__(self, *args)
+        self.header = "find_noncopyable_vars.hpp"
+        decls = parser.parse([self.header], self.config)
+        self.global_ns = declarations.get_global_namespace(decls)
+
+    def test(self):
+        """
+        Test the find_noncopyable_vars function
+
+        """
+
+        # The ptr1 variable in the holder struct can be copied,
+        # but not the ptr2 variable
+        holder = self.global_ns.class_("holder")
+        nc_vars = declarations.find_noncopyable_vars(holder)
+        self.assertEqual(len(nc_vars), 1)
+        self.assertEqual(nc_vars[0].name, "ptr2")
+        self.assertTrue(declarations.is_pointer(nc_vars[0].decl_type))
+        self.assertTrue(declarations.is_const(nc_vars[0].decl_type))
+
+
+def create_suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(Test))
+    return suite
+
+
+def run_suite():
+    unittest.TextTestRunner(verbosity=2).run(create_suite())
+
+
+if __name__ == "__main__":
+    run_suite()

unittests/test_smart_pointer.py

@@ -17,40 +17,93 @@ def __init__(self, *args):
         parser_test_case.parser_test_case_t.__init__(self, *args)
         self.header = "test_smart_pointer.hpp"
         self.config.cflags = "-std=c++11"
+        self.global_ns = None
 
-    def test_smart_pointer(self):
+    def setUp(self):
+        if self.config.xml_generator == "gccxml":
+            return
+        decls = parser.parse([self.header], self.config)
+        self.global_ns = declarations.get_global_namespace(decls)
+
+    def test_is_smart_pointer(self):
         """
-        Test code in the smart_pointer_traits module.
+        Test smart_pointer_traits.is_smart_pointer method.
 
         """
 
         if self.config.xml_generator == "gccxml":
             return
 
-        decls = parser.parse([self.header], self.config)
-        global_ns = declarations.get_global_namespace(decls)
-
         criteria = declarations.declaration_matcher(name="yes1")
-        decls = declarations.matcher.find(criteria, global_ns)
+        decls = declarations.matcher.find(criteria, self.global_ns)
         self.assertTrue(
             declarations.smart_pointer_traits.is_smart_pointer(
                 decls[0].decl_type))
 
+        criteria = declarations.declaration_matcher(name="no1")
+        decls = declarations.matcher.find(criteria, self.global_ns)
+        self.assertFalse(
+            declarations.smart_pointer_traits.is_smart_pointer(
+                decls[0].decl_type))
+
+        criteria = declarations.declaration_matcher(name="no2")
+        decls = declarations.matcher.find(criteria, self.global_ns)
+        self.assertFalse(
+            declarations.smart_pointer_traits.is_smart_pointer(
+                decls[0].decl_type))
+
+    def test_is_auto_pointer(self):
+        """
+        Test auto_ptr_traits.is_smart_pointer method.
+
+        """
+
+        if self.config.xml_generator == "gccxml":
+            return
+
         criteria = declarations.declaration_matcher(name="yes2")
-        decls = declarations.matcher.find(criteria, global_ns)
+        decls = declarations.matcher.find(criteria, self.global_ns)
         self.assertTrue(
             declarations.auto_ptr_traits.is_smart_pointer(decls[0].decl_type))
 
         criteria = declarations.declaration_matcher(name="no1")
-        decls = declarations.matcher.find(criteria, global_ns)
+        decls = declarations.matcher.find(criteria, self.global_ns)
         self.assertFalse(
             declarations.auto_ptr_traits.is_smart_pointer(decls[0].decl_type))
 
         criteria = declarations.declaration_matcher(name="no2")
-        decls = declarations.matcher.find(criteria, global_ns)
+        decls = declarations.matcher.find(criteria, self.global_ns)
         self.assertFalse(
             declarations.auto_ptr_traits.is_smart_pointer(decls[0].decl_type))
 
+    def test_smart_pointer_value_type(self):
+        """
+        Test smart_pointer_traits.value_type method.
+
+        """
+
+        if self.config.xml_generator == "gccxml":
+            return
+
+        criteria = declarations.declaration_matcher(name="yes1")
+        decls = declarations.matcher.find(criteria, self.global_ns)
+        vt = declarations.smart_pointer_traits.value_type(decls[0].decl_type)
+        self.assertIsInstance(vt, declarations.int_t)
+
+    def test_auto_pointer_value_type(self):
+        """
+        Test auto_pointer_traits.value_type method.
+
+        """
+
+        if self.config.xml_generator == "gccxml":
+            return
+
+        criteria = declarations.declaration_matcher(name="yes2")
+        decls = declarations.matcher.find(criteria, self.global_ns)
+        vt = declarations.auto_ptr_traits.value_type(decls[0].decl_type)
+        self.assertIsInstance(vt, declarations.double_t)
+
 
 def create_suite():
     suite = unittest.TestSuite()