Fix handling of typedef unions and function pointers

Typedef unions were not properly being parsed when the member types were
unknown.  These will now be parsed, but the types will fall back to
"int", per clang.

typedef of functions or function pointers with unknown types were not
properly being parsed now they will come back though they will default
to int return types for unknown types.

Author: speedyleion

src/sphinx_c_autodoc/loader.py

@@ -203,7 +203,12 @@ def get_soup_declaration(self) -> Optional[str]:
 
         root = self.soup.contents[0]
 
-        return root.declaration.text
+        # It seems with different versions of clang the newlines will at times
+        # be kept around from some declarations. This causes problems with
+        # sphinx as the signature should remain all in one line.
+        lines = root.declaration.text.splitlines()
+        declaration = " ".join(l.strip() for l in lines)
+        return declaration
 
     @property
     def soup(self) -> Optional[BeautifulSoup]:
@@ -507,6 +512,27 @@ def get_parsed_declaration(self) -> str:
         For things like functions and others this will include the return type.
         """
         parent_type = self.node.underlying_typedef_type.spelling
+
+        # Function prototypes need to be handled different. When clang can't
+        # successfully parse the file it falls back to naming the return type
+        # as the display name.
+        # Unfortunatly some versions of clang behave a little differently, some
+        # will return a POINTER while others will return FUNCITONNOPROTO. The
+        # POINTER's are easy to derive the real type from, but the test
+        # environment doesn't use that version of clang.
+        type_ = self.node.underlying_typedef_type
+        if type_.kind == cindex.TypeKind.POINTER:  # pragma: no cover
+            type_ = type_.get_pointee()
+
+        if type_.kind in (
+            cindex.TypeKind.FUNCTIONPROTO,
+            cindex.TypeKind.FUNCTIONNOPROTO,
+        ):
+            ret_value, paren, signature = parent_type.partition(")")
+            signature = "".join((ret_value, self.name, paren, signature))
+
+            return f"typedef {signature}"
+
         return f"typedef {parent_type} {self.name}"
 
 
@@ -522,7 +548,7 @@ def soup(self) -> None:
         """
         Since structures like objects use the "Members:" and
         "Enumerations:" sections do *not* use the clang xml comments as they
-        don't preseve newlines, so the sections get lost.
+        don't preserve newlines, so the sections get lost.
         """
         return None
 
@@ -664,6 +690,7 @@ def get_nested_node(cursor: Cursor) -> Cursor:
             underlying_node = next(cursor.get_children())
             if underlying_node.kind in (
                 cindex.CursorKind.STRUCT_DECL,
+                cindex.CursorKind.UNION_DECL,
                 cindex.CursorKind.ENUM_DECL,
             ):
                 return underlying_node

tests/assets/c_source_2/nested/types.c

@@ -97,4 +97,34 @@ struct nested_struct
         int nested_two;
     } two;
     float three;
-};
+};
+
+/**
+ * A typedefed union
+ */
+typedef union
+{
+unknown_type one;
+another_unknown two;
+} a_union_typedef;
+
+/**
+ * A function type with unknown return type. This will for the generic parsing
+ * to happen instead of the clang soup
+ */
+
+typedef unknown_return_type (function_type)(const unknown_type * foo, const unknonw_two * yes);
+
+/**
+ * A function pointer type with unknown return type
+ */
+typedef what (*function_pointer_type)(const int * hello, const foo_type baz);
+
+/**
+ * A function pointer wrapped on multiple lines.
+ */
+typedef int (*wrapped_function_pointer)
+    (
+    const int * hello,
+    const float baz
+    );

tests/directives/test_autoctype.py

@@ -106,6 +106,35 @@ class TestAutoCType:
         float three
         The third member of parent struct"""
 
+    # Not fond of the int, but clang reduces it to this, need to find a way to
+    # read those back when clang fails.
+    a_union_typedef = """\
+        union a_union_typedef
+        A typedefed union
+
+        int one
+
+
+        int two
+        """
+
+    # Similar to the unknown members of the union clang just falls back to
+    # int's
+    function_type = """\
+        typedef intunknown_return_type
+        A function type with unknown return type. This will for the generic parsing
+        to happen instead of the clang soup"""
+
+    # Similar to the unknown members of the union clang just falls back to
+    # int's
+    function_pointer_type = """\
+        typedef intint\xa0*what
+        A function pointer type with unknown return type"""
+
+    wrapped_function_pointer = """\
+        typedef int (*wrapped_function_pointer)const int *, const float
+        A function pointer wrapped on multiple lines."""
+
     doc_data = [
         ("types.c::my_int", my_int),
         ("types.c::my_struct_type", my_struct_type),
@@ -116,6 +145,10 @@ class TestAutoCType:
         ("types.c::a_union_type", a_union_type),
         ("types.c::a_multiply_documented_union_type", a_multiply_documented_union_type),
         ("types.c::nested_struct", nested_struct),
+        ("types.c::a_union_typedef", a_union_typedef),
+        ("types.c::unknown_return_type", function_type),
+        ("types.c::what", function_pointer_type),
+        ("types.c::wrapped_function_pointer", wrapped_function_pointer),
     ]
 
     @pytest.mark.parametrize("type_, expected_doc", doc_data)