Add support for C++20 abbreviated function templates

Co-authored-by: David Vo <auscompgeek@users.noreply.github.com>

Author: virtuald

cxxheaderparser/parser.py

@@ -606,9 +606,13 @@ def _parse_template_decl(self) -> TemplateDecl:
                         lex.return_token(ptok)
                         param = self._parse_template_type_parameter(tok, None)
                     else:
-                        param = self._parse_parameter(ptok, TemplateNonTypeParam, ">")
+                        param, _ = self._parse_parameter(
+                            ptok, TemplateNonTypeParam, False, ">"
+                        )
                 else:
-                    param = self._parse_parameter(tok, TemplateNonTypeParam, ">")
+                    param, _ = self._parse_parameter(
+                        tok, TemplateNonTypeParam, concept_ok=False, end=">"
+                    )
 
                 params.append(param)
 
@@ -1644,23 +1648,43 @@ def _parse_pqname(
     #
 
     def _parse_parameter(
-        self, tok: typing.Optional[LexToken], cls: typing.Type[PT], end: str = ")"
-    ) -> PT:
+        self,
+        tok: typing.Optional[LexToken],
+        cls: typing.Type[PT],
+        concept_ok: bool,
+        end: str = ")",
+    ) -> typing.Tuple[PT, typing.Optional[Type]]:
         """
         Parses a single parameter (excluding vararg parameters). Also used
         to parse template non-type parameters
+
+        Returns parameter type, abbreviated template type
         """
 
         param_name = None
         default = None
         param_pack = False
+        parsed_type: typing.Optional[Type]
+        at_type: typing.Optional[Type] = None
 
-        # required typename + decorators
-        parsed_type, mods = self._parse_type(tok)
-        if parsed_type is None:
-            raise self._parse_error(None)
+        if not tok:
+            tok = self.lex.token()
 
-        mods.validate(var_ok=False, meth_ok=False, msg="parsing parameter")
+        # placeholder type, skip typename
+        if tok.type == "auto":
+            at_type = parsed_type = Type(PQName([AutoSpecifier()]))
+        else:
+            # required typename + decorators
+            parsed_type, mods = self._parse_type(tok)
+            if parsed_type is None:
+                raise self._parse_error(None)
+
+            mods.validate(var_ok=False, meth_ok=False, msg="parsing parameter")
+
+            # Could be a concept
+            if concept_ok and self.lex.token_if("auto"):
+                at_type = Type(parsed_type.typename)
+                parsed_type.typename = PQName([AutoSpecifier()])
 
         dtype = self._parse_cv_ptr(parsed_type)
 
@@ -1688,32 +1712,50 @@ def _parse_parameter(
         if self.lex.token_if("="):
             default = self._create_value(self._consume_value_until([], ",", end))
 
+        # abbreviated template pack
+        if at_type and self.lex.token_if("ELLIPSIS"):
+            param_pack = True
+
         param = cls(type=dtype, name=param_name, default=default, param_pack=param_pack)
         self.debug_print("parameter: %s", param)
-        return param
+        return param, at_type
 
-    def _parse_parameters(self) -> typing.Tuple[typing.List[Parameter], bool]:
+    def _parse_parameters(
+        self, concept_ok: bool
+    ) -> typing.Tuple[typing.List[Parameter], bool, typing.List[TemplateParam]]:
         """
-        Consumes function parameters and returns them, and vararg if found
+        Consumes function parameters and returns them, and vararg if found, and
+        promotes abbreviated template parameters to actual template parameters
+        if concept_ok is True
         """
 
         # starting at a (
 
         # special case: zero parameters
         if self.lex.token_if(")"):
-            return [], False
+            return [], False, []
 
         params: typing.List[Parameter] = []
         vararg = False
+        at_params: typing.List[TemplateParam] = []
 
         while True:
             if self.lex.token_if("ELLIPSIS"):
                 vararg = True
                 self._next_token_must_be(")")
                 break
 
-            param = self._parse_parameter(None, Parameter)
+            param, at_type = self._parse_parameter(None, Parameter, concept_ok)
             params.append(param)
+            if at_type:
+                at_params.append(
+                    TemplateNonTypeParam(
+                        type=at_type,
+                        param_idx=len(params) - 1,
+                        param_pack=param.param_pack,
+                    )
+                )
+
             tok = self._next_token_must_be(",", ")")
             if tok.value == ")":
                 break
@@ -1728,7 +1770,7 @@ def _parse_parameters(self) -> typing.Tuple[typing.List[Parameter], bool]:
             ):
                 params = []
 
-        return params, vararg
+        return params, vararg, at_params
 
     _auto_return_typename = PQName([AutoSpecifier()])
 
@@ -1875,7 +1917,16 @@ def _parse_function(
         state.location = location
         is_class_block = isinstance(state, ClassBlockState)
 
-        params, vararg = self._parse_parameters()
+        params, vararg, at_params = self._parse_parameters(True)
+
+        # Promote abbreviated template parameters
+        if at_params:
+            if template is None:
+                template = TemplateDecl(at_params)
+            elif isinstance(template, TemplateDecl):
+                template.params.extend(at_params)
+            else:
+                template[-1].params.extend(at_params)
 
         # A method outside of a class has multiple name segments
         multiple_name_segments = len(pqname.segments) > 1
@@ -2048,7 +2099,7 @@ def _parse_cv_ptr_or_fn(
                     toks = self._consume_balanced_tokens(gtok)
                     self.lex.return_tokens(toks[1:-1])
 
-                fn_params, vararg = self._parse_parameters()
+                fn_params, vararg, _ = self._parse_parameters(False)
 
                 assert not isinstance(dtype, FunctionType)
                 dtype = dtype_fn = FunctionType(dtype, fn_params, vararg)
@@ -2076,7 +2127,7 @@ def _parse_cv_ptr_or_fn(
                         assert not isinstance(dtype, FunctionType)
                         dtype = self._parse_array_type(aptok, dtype)
                     elif aptok.type == "(":
-                        fn_params, vararg = self._parse_parameters()
+                        fn_params, vararg, _ = self._parse_parameters(False)
                         # the type we already have is the return type of the function pointer
 
                         assert not isinstance(dtype, FunctionType)

cxxheaderparser/types.py

@@ -454,12 +454,19 @@ class TemplateNonTypeParam:
 
        template <auto T>
                  ~~~~~~
+
+       // abbreviated template parameters are converted to this and param_idx is set
+       void fn(C auto p)
+               ~~~~~~
     """
 
     type: DecoratedType
     name: typing.Optional[str] = None
     default: typing.Optional[Value] = None
 
+    #: If this was promoted, the parameter index that this corresponds with
+    param_idx: typing.Optional[int] = None
+
     #: Contains a ``...``
     param_pack: bool = False