Merge pull request #150 from robotpy/non-ptr-fn-arg

Add support for non-pointer function arguments

Author: virtuald

cxxheaderparser/parser.py

@@ -1971,6 +1971,14 @@ def _parse_parameter(
         if tok:
             param_name = tok.value
 
+        # Function parameter declarations can use function declarator syntax,
+        # e.g. ``bool predicate(const T&)``. In parameter lists, function types
+        # are adjusted to pointers to functions, matching the explicit
+        # ``bool (*predicate)(const T&)`` spelling.
+        if param_name and self.lex.token_if("("):
+            fn_params, vararg, _ = self._parse_parameters(False, False)
+            dtype = Pointer(FunctionType(dtype, fn_params, vararg))
+
         # optional array parameter
         tok = self.lex.token_if("[")
         if tok:

tests/test_fn.py

@@ -33,6 +33,58 @@
 )
 
 
+def test_fn_parameter_named_function_declarator() -> None:
+    content = """
+      template <typename T> void RemoveIf(bool predicate(const T& key));
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            functions=[
+                Function(
+                    return_type=Type(
+                        typename=PQName(segments=[FundamentalSpecifier(name="void")])
+                    ),
+                    name=PQName(segments=[NameSpecifier(name="RemoveIf")]),
+                    parameters=[
+                        Parameter(
+                            type=Pointer(
+                                ptr_to=FunctionType(
+                                    return_type=Type(
+                                        typename=PQName(
+                                            segments=[FundamentalSpecifier(name="bool")]
+                                        )
+                                    ),
+                                    parameters=[
+                                        Parameter(
+                                            type=Reference(
+                                                ref_to=Type(
+                                                    typename=PQName(
+                                                        segments=[
+                                                            NameSpecifier(name="T")
+                                                        ]
+                                                    ),
+                                                    const=True,
+                                                )
+                                            ),
+                                            name="key",
+                                        )
+                                    ],
+                                )
+                            ),
+                            name="predicate",
+                        )
+                    ],
+                    template=TemplateDecl(
+                        params=[TemplateTypeParam(typekey="typename", name="T")]
+                    ),
+                )
+            ]
+        )
+    )
+
+
 def test_fn_returns_class() -> None:
     content = """
       class X *fn1();