Fixes for type traits handling of cv-qualified array types

cv-qualified arrays were not being handled correctly by type traits
manipulations functions. For instance, 'int const[N]' would not be
detected as 'const'. Similar problems existed for volatile qualified
arrays too.

There is a difference in behavior between GCCXML and CastXML for cv-qual
arrays. GCCXML produces the following nesting of types:
   ->  volatile_t(const_t(array_t))
while CastXML produces the following nesting:
   ->  array_t(volatile_t(const_t))
For both cases, we must unwrap the types, remove const_t, and add back
the outer layers.

Prior to CastXML/CastXML#55 being fixed, CastXML would incorrectly
generate default constructor definitions for types with const data
members. This caused pygccxml to incorrectly flag such types as
trivially constructible.

These tests have now been fixed, and the tests are being executed
conditionally only for GCCXML (which handles them correctly), or, if
CastXML is being used, then for xml_output_version >= 1.138.

gccxml places cv-qualifiers to the right of the array declarator in the
decl_string. For instance, given the declaration 'int const[arr[42]',
the decl_string from gccxml is 'int [42] const'.

Combined type_traits_castxml.hpp and type_traits_gccxml.hpp into a
single file - type_traits.hpp.

Change-Id: If5deaecf4cc9ab38cb8b8ac90befa9c62ebd0106

This commit was cherry-picked from the develop branch.

Conflicts:
	unittests/data/type_traits_castxml.hpp
	unittests/type_traits_tester.py

Note: the decl_type attributes in array_bug_tester.py were replaced
by type attributes. The decl_type attributes only exist on develop.

Author: praetorian20

pygccxml/declarations/type_traits.py

@@ -284,19 +284,46 @@ def remove_reference(type):
 def is_const(type):
     """returns True, if type represents C++ const type, False otherwise"""
     nake_type = remove_alias(type)
-    return isinstance(nake_type, cpptypes.const_t)
+    if isinstance(nake_type, cpptypes.const_t):
+        return True
+    elif isinstance(nake_type, cpptypes.volatile_t):
+        return is_const(nake_type.base)
+    elif isinstance(nake_type, cpptypes.array_t):
+        return is_const(nake_type.base)
+    return False
 
 
-def remove_const(type):
+def remove_const(type_):
     """removes const from the type definition
 
     If type is not const type, it will be returned as is
     """
 
-    nake_type = remove_alias(type)
+    nake_type = remove_alias(type_)
     if not is_const(nake_type):
-        return type
+        return type_
     else:
+        # Handling for const and volatile qualified types. There is a
+        # difference in behavior between GCCXML and CastXML for cv-qual arrays.
+        # GCCXML produces the following nesting of types:
+        #       ->  volatile_t(const_t(array_t))
+        # while CastXML produces the following nesting:
+        #       ->  array_t(volatile_t(const_t))
+        # For both cases, we must unwrap the types, remove const_t, and add
+        # back the outer layers
+        if isinstance(nake_type, cpptypes.array_t):
+            is_v = is_volatile(nake_type)
+            if is_v:
+                result_type = nake_type.base.base.base
+            else:
+                result_type = nake_type.base.base
+            if is_v:
+                result_type = cpptypes.volatile_t(result_type)
+            return cpptypes.array_t(result_type, nake_type.size)
+
+        elif isinstance(nake_type, cpptypes.volatile_t):
+            return cpptypes.volatile_t(nake_type.base.base)
+
         return nake_type.base
 
 
@@ -322,7 +349,13 @@ def is_same(type1, type2):
 def is_volatile(type):
     """returns True, if type represents C++ volatile type, False otherwise"""
     nake_type = remove_alias(type)
-    return isinstance(nake_type, cpptypes.volatile_t)
+    if isinstance(nake_type, cpptypes.volatile_t):
+        return True
+    elif isinstance(nake_type, cpptypes.const_t):
+        return is_volatile(nake_type.base)
+    elif isinstance(nake_type, cpptypes.array_t):
+        return is_volatile(nake_type.base)
+    return False
 
 
 def remove_volatile(type):
@@ -334,6 +367,16 @@ def remove_volatile(type):
     if not is_volatile(nake_type):
         return type
     else:
+        if isinstance(nake_type, cpptypes.array_t):
+            is_c = is_const(nake_type)
+            if is_c:
+                base_type = nake_type.base.base.base
+            else:
+                base_type = nake_type.base.base
+            result_type = base_type
+            if is_c:
+                result_type = cpptypes.const_t(result_type)
+            return cpptypes.array_t(result_type, nake_type.size)
         return nake_type.base
 
 
@@ -344,12 +387,12 @@ def remove_cv(type):
     if not is_const(nake_type) and not is_volatile(nake_type):
         return type
     result = nake_type
-    if is_const(nake_type):
-        result = nake_type.base
+    if is_const(result):
+        result = remove_const(result)
     if is_volatile(result):
-        result = result.base
+        result = remove_volatile(result)
     if is_const(result):
-        result = result.base
+        result = remove_const(result)
     return result
 
 

unittests/array_bug_tester.py

@@ -55,6 +55,65 @@ def test4(self):
             '::xyz[2][3]' == aaaa_type.decl_string,
             aaaa_type.decl_string)
 
+    def test5(self):
+        code = 'char const arr[4] = {};'
+        src_reader = parser.source_reader_t(self.config)
+        global_ns = declarations.get_global_namespace(
+            src_reader.read_string(code))
+        arr_type = global_ns.variable('arr').type
+        if self.config.xml_generator == "gccxml":
+            self.assertTrue(
+                'char[4] const' == arr_type.decl_string,
+                arr_type.decl_string)
+        else:
+            self.assertTrue(
+                'char const[4]' == arr_type.decl_string,
+                arr_type.decl_string)
+        self.assertTrue(
+            declarations.is_array(arr_type))
+        self.assertTrue(
+            declarations.is_const(arr_type))
+
+    def test6(self):
+        code = 'char volatile arr[4] = {};'
+        src_reader = parser.source_reader_t(self.config)
+        global_ns = declarations.get_global_namespace(
+            src_reader.read_string(code))
+        arr_type = global_ns.variable('arr').type
+        if self.config.xml_generator == "gccxml":
+            self.assertTrue(
+                'char[4] volatile' == arr_type.decl_string,
+                arr_type.decl_string)
+        else:
+            self.assertTrue(
+                'char volatile[4]' == arr_type.decl_string,
+                arr_type.decl_string)
+        self.assertTrue(
+            declarations.is_array(arr_type))
+        self.assertTrue(
+            declarations.is_volatile(arr_type))
+
+    def test7(self):
+        code = 'char const volatile arr[4] = {};'
+        src_reader = parser.source_reader_t(self.config)
+        global_ns = declarations.get_global_namespace(
+            src_reader.read_string(code))
+        arr_type = global_ns.variable('arr').type
+        if self.config.xml_generator == "gccxml":
+            self.assertTrue(
+                'char[4] const volatile' == arr_type.decl_string,
+                arr_type.decl_string)
+        else:
+            self.assertTrue(
+                'char const volatile[4]' == arr_type.decl_string,
+                arr_type.decl_string)
+        self.assertTrue(
+            declarations.is_array(arr_type))
+        self.assertTrue(
+            declarations.is_const(arr_type))
+        self.assertTrue(
+            declarations.is_volatile(arr_type))
+
 
 def create_suite():
     suite = unittest.TestSuite()

unittests/data/type_traits_gccxml.hpp renamed to unittests/data/type_traits.hpp

@@ -19,6 +19,7 @@
     typedef BASE volatile NAME##_volatile_t;                  \
     typedef BASE const volatile NAME##_const_volatile_t;
 
+
 struct some_struct_t{
     void do_smth();
     int member;
@@ -47,9 +48,7 @@ struct incomplete_type;
 
 namespace is_void{
 namespace yes{
-    typedef void void_t;
-    typedef void const void_cont_t;
-    typedef void volatile void_volatile_t;
+    TYPE_PERMUTATION( void, void )
 }
 namespace no{
     typedef void* void_ptr_t;
@@ -186,7 +185,6 @@ namespace yes{
     typedef detail::dd_t dd_t;
     typedef detail::f_t f_t;
     typedef detail::g_t g_t;
-
     typedef detail::const_container const_container_t;
     typedef detail::const_item const_item_t;
 
@@ -287,11 +285,6 @@ namespace no{
 namespace is_fundamental{
 namespace yes{
 
-#define FUNDAMENTAL_TYPE_PERMUTATION( BASE, NAME )            \
-    typedef BASE NAME##_t;                                     \
-    typedef BASE const NAME##_const_t;                         \
-    typedef BASE volatile NAME##_volatile_t;
-
     TYPE_PERMUTATION( void, void )
     TYPE_PERMUTATION( bool, bool )
     TYPE_PERMUTATION( char, char )
@@ -409,7 +402,8 @@ namespace yes{
     typedef const void const_void_t;
     typedef const incomplete_type const_incomplete_type_t;
     typedef int* const int_const_t;
-    //TODO typedef const int& const_int_ref_t;
+    typedef int* volatile const int_volatile_const_t;
+    typedef int* const volatile int_const_volatile_t;
 }
 
 namespace no{
@@ -421,32 +415,53 @@ namespace no{
     typedef void(*function_t)();
     typedef void (some_struct_t::*member_function_t)();
     typedef int int_t;
+    typedef const int& const_int_ref_t;
 } }
 
 namespace remove_const{
 namespace before{
-
     typedef const void x1;
     typedef const incomplete_type x2;
     typedef int* const x3;
     typedef int* volatile x4;
+    typedef void const * x5;
+    typedef int volatile const x6;
+    typedef int const volatile x7;
+
+    typedef char arr_42[42];
+    typedef char const arr_c_42[42];
+    typedef char volatile arr_v_42[42];
+    typedef char const volatile arr_cv_42[42];
+    typedef char volatile const arr_vc_42[42];
 }
 
 namespace after{
     typedef void x1;
     typedef incomplete_type x2;
     typedef int* x3;
     typedef int* volatile x4;
+    typedef void const * x5;
+    typedef int volatile x6;
+    typedef int volatile x7;
+
+    typedef char arr_42[42];
+    typedef char arr_c_42[42];
+    typedef char volatile arr_v_42[42];
+    typedef char volatile arr_cv_42[42];
+    typedef char volatile arr_vc_42[42];
 } }
 
 namespace is_volatile{
 namespace yes{
 
     typedef void * volatile vvoid_ptr_t;
     typedef volatile int volatile_int_t;
+    typedef int* volatile const int_volatile_const_t;
+    typedef int* const volatile int_const_volatile_t;
 }
 
 namespace no{
+    typedef void volatile * void_ptr_to_v_t;
     typedef int* int_ptr_t;
     typedef const int* const_int_ptr_t;
     typedef int* volatile_int_ptr_t;
@@ -463,12 +478,30 @@ namespace before{
     typedef void * volatile x1;
     typedef volatile int x2;
     typedef int* x3;
+    typedef void volatile * x4;
+    typedef int volatile const x5;
+    typedef int const volatile x6;
+
+    typedef char arr_42[42];
+    typedef char const arr_c_42[42];
+    typedef char volatile arr_v_42[42];
+    typedef char const volatile arr_cv_42[42];
+    typedef char volatile const arr_vc_42[42];
 }
 
 namespace after{
     typedef void * x1;
     typedef int x2;
     typedef int* x3;
+    typedef void volatile * x4;
+    typedef int const x5;
+    typedef int const x6;
+
+    typedef char arr_42[42];
+    typedef char const arr_c_42[42];
+    typedef char arr_v_42[42];
+    typedef char const arr_cv_42[42];
+    typedef char const arr_vc_42[42];
 } }
 
 
@@ -488,6 +521,12 @@ namespace before{
     typedef int* const x32;
 
     typedef void(*x40)();
+
+    typedef char arr_42[42];
+    typedef char const arr_c_42[42];
+    typedef char volatile arr_v_42[42];
+    typedef char const volatile arr_cv_42[42];
+    typedef char volatile const arr_vc_42[42];
 }
 
 namespace after{
@@ -504,6 +543,12 @@ namespace after{
     typedef int* x32;
 
     typedef void(*x40)();
+
+    typedef char arr_42[42];
+    typedef char arr_c_42[42];
+    typedef char arr_v_42[42];
+    typedef char arr_cv_42[42];
+    typedef char arr_vc_42[42];
 } }
 
 
@@ -548,9 +593,6 @@ namespace yes{
 
 namespace no{
 
-    typedef details::const_item const_item;
-    typedef details::const_container const_container;
-
     class y{
         private:
         y(){}
@@ -567,6 +609,9 @@ namespace no{
     public:
         static singleton_t* instance();
     };
+
+    typedef details::const_item const_item;
+    typedef details::const_container const_container;
 } }
 
 namespace has_public_constructor{
@@ -663,6 +708,7 @@ namespace yes{
     const int yes2[2] = {0};
     const volatile int yes3[2] = {0};
     int yes4[2][3];
+    int const yes5[2] = {0};
 }
 
 namespace no{