cxxheaderparser 1.7.0__tar.gz → 1.7.2__tar.gz

{cxxheaderparser-1.7.0 → cxxheaderparser-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cxxheaderparser
-Version: 1.7.0
+Version: 1.7.2
 Summary: Modern C++ header parser
 Project-URL: Source code, https://github.com/robotpy/cxxheaderparser
 Author-email: Dustin Spicuzza <robotpy@googlegroups.com>

{cxxheaderparser-1.7.0 → cxxheaderparser-1.7.2}/cxxheaderparser/gentest.py

@@ -1,5 +1,6 @@
 import argparse
 import dataclasses
+import enum
 import inspect
 import subprocess
 import textwrap
@@ -44,6 +45,8 @@ def nondefault_repr(data: typing.Any) -> str:
             for k, v in o.items():
                 vals.append(f'"{k}": {_inner_repr(v)}')
             return "{" + ",".join(vals) + "}"
+        elif isinstance(o, enum.Enum):
+            return f"{o.__class__.__qualname__}.{o.name}"
         else:
             return repr(o)
 

{cxxheaderparser-1.7.0 → cxxheaderparser-1.7.2}/cxxheaderparser/parser.py

@@ -19,6 +19,8 @@ from .parserstate import (
 from .types import (
     AnonymousName,
     Array,
+    Attribute,
+    AttributeStyle,
     AutoSpecifier,
     BaseClass,
     ClassDecl,
@@ -104,6 +106,7 @@ class CxxParser:
             None, self.lex.current_location(), global_ns
         )
         self.anon_id = 0
+        self._pending_attributes: typing.List[Attribute] = []
 
         self.verbose = self.options.verbose
         if self.verbose:
@@ -907,38 +910,116 @@ class CxxParser:
     }
     _attribute_start_tokens |= _attribute_specifier_seq_start_types
 
-    def _consume_attribute(self, tok: LexToken) -> None:
+    def _record_attributes(self, attrs: typing.Iterable[Attribute]) -> None:
+        self._pending_attributes.extend(attrs)
+
+    def _take_pending_attributes(self) -> typing.List[Attribute]:
+        attrs = self._pending_attributes
+        self._pending_attributes = []
+        return attrs
+
+    def _parse_attribute_list_tokens(
+        self, kind: AttributeStyle, *init_tokens: LexToken
+    ) -> typing.List[Attribute]:
+
+        match_stack = [self._balanced_token_map[tok.type] for tok in init_tokens]
+        get_token = self.lex.token
+
+        attrs = []
+        name_tokens: typing.List[LexToken] = []
+
+        def _commit(value: typing.Optional[Value]) -> None:
+            name = "".join(tok.value for tok in name_tokens).strip()
+            name_tokens.clear()
+            if name:
+                attrs.append(Attribute(style=kind, name=name, value=value))
+            elif value is not None:
+                raise self._parse_error(None, expected="missing attribute name")
+
+        while True:
+            tok = get_token()
+            if tok.type in self._end_balanced_tokens:
+                expected = match_stack[-1]
+                if tok.type != expected:
+                    raise self._parse_error(tok, expected)
+
+                if name_tokens:
+                    _commit(None)
+
+                if len(match_stack) == 2:
+                    self._next_token_must_be(match_stack[0])
+
+                break
+
+            elif tok.type in self._balanced_token_map:
+                _commit(self._create_value(self._consume_balanced_tokens(tok)[1:-1]))
+            elif tok.type == ",":
+                _commit(None)
+            else:
+                name_tokens.append(tok)
+
+        return attrs
+
+    def _consume_attribute(
+        self,
+        tok: LexToken,
+        doxygen: typing.Optional[str] = None,
+        *,
+        record: bool = True,
+    ) -> typing.List[Attribute]:
         if tok.type == "__attribute__":
-            self._consume_gcc_attribute(tok)
+            attrs = self._consume_gcc_attribute(tok, doxygen, record=record)
         elif tok.type == "__declspec":
-            self._consume_declspec(tok)
+            attrs = self._consume_declspec(tok, doxygen, record=record)
         elif tok.type in self._attribute_specifier_seq_start_types:
-            self._consume_attribute_specifier_seq(tok)
+            attrs = self._consume_attribute_specifier_seq(tok, doxygen, record=record)
         else:
             raise CxxParseError("internal error")
+        return attrs
 
     def _consume_gcc_attribute(
-        self, tok: typing.Optional[LexToken], doxygen: typing.Optional[str] = None
-    ) -> None:
+        self,
+        tok: typing.Optional[LexToken],
+        doxygen: typing.Optional[str] = None,
+        *,
+        record: bool = True,
+    ) -> typing.List[Attribute]:
+        attrs: typing.List[Attribute] = []
         while True:
             tok1 = self._next_token_must_be("(")
             tok2 = self._next_token_must_be("(")
-            self._consume_balanced_tokens(tok1, tok2)
+            attrs.extend(
+                self._parse_attribute_list_tokens(AttributeStyle.GCC, tok1, tok2)
+            )
 
             # Apparently you can have multiple attributes chained together?
             tok = self.lex.token_if("__attribute__")
             if tok is None:
                 break
+        if record:
+            self._record_attributes(attrs)
+        return attrs
 
     def _consume_declspec(
-        self, tok: LexToken, doxygen: typing.Optional[str] = None
-    ) -> None:
+        self,
+        tok: LexToken,
+        doxygen: typing.Optional[str] = None,
+        *,
+        record: bool = True,
+    ) -> typing.List[Attribute]:
         tok = self._next_token_must_be("(")
-        self._consume_balanced_tokens(tok)
+        attrs = self._parse_attribute_list_tokens(AttributeStyle.MSVC, tok)
+        if record:
+            self._record_attributes(attrs)
+        return attrs
 
     def _consume_attribute_specifier_seq(
-        self, tok: LexToken, doxygen: typing.Optional[str] = None
-    ) -> None:
+        self,
+        tok: LexToken,
+        doxygen: typing.Optional[str] = None,
+        *,
+        record: bool = True,
+    ) -> typing.List[Attribute]:
         """
         attribute_specifier_seq: attribute_specifier
                                | attribute_specifier_seq attribute_specifier
@@ -974,17 +1055,20 @@ class CxxParser:
                       | token
         """
 
-        # TODO: retain the attributes and do something with them
-        # attrs = []
-
+        attrs: typing.List[Attribute] = []
         while True:
             if tok.type == "DBL_LBRACKET":
-                tokens = self._consume_balanced_tokens(tok)
-                # attrs.append(Attribute(tokens))
+                attrs.extend(self._parse_attribute_list_tokens(AttributeStyle.CXX, tok))
             elif tok.type == "alignas":
                 next_tok = self._next_token_must_be("(")
                 tokens = self._consume_balanced_tokens(next_tok)
-                # attrs.append(AlignasAttribute(tokens))
+                attrs.append(
+                    Attribute(
+                        style=AttributeStyle.CXX,
+                        name="alignas",
+                        value=self._create_value(tokens[1:-1]),
+                    )
+                )
             else:
                 self.lex.return_token(tok)
                 break
@@ -996,7 +1080,18 @@ class CxxParser:
 
             tok = maybe_tok
 
-        # TODO return attrs
+        if record:
+            self._record_attributes(attrs)
+        return attrs
+
+    def _consume_decl_attributes(self) -> typing.List[Attribute]:
+        attrs: typing.List[Attribute] = []
+        while True:
+            tok = self.lex.token_if_in_set(self._attribute_start_tokens)
+            if not tok:
+                break
+            attrs.extend(self._consume_attribute(tok, record=False))
+        return attrs
 
     #
     # Using directive/declaration/typealias
@@ -1109,6 +1204,7 @@ class CxxParser:
         is_typedef: bool,
         location: Location,
         mods: ParsedTypeModifiers,
+        attributes: typing.List[Attribute],
     ) -> None:
         """
         opaque_enum_declaration: enum_key [attribute_specifier_seq] IDENTIFIER [enum_base] ";"
@@ -1148,18 +1244,29 @@ class CxxParser:
 
                 # enum forward declaration with base
                 fdecl = ForwardDecl(
-                    typename, None, doxygen, base, access=self._current_access
+                    typename,
+                    None,
+                    doxygen,
+                    attributes=attributes,
+                    enum_base=base,
+                    access=self._current_access,
                 )
                 self.visitor.on_forward_decl(self.state, fdecl)
                 return
 
         values = self._parse_enumerator_list()
 
-        enum = EnumDecl(typename, values, base, doxygen, self._current_access)
+        enum = EnumDecl(
+            typename, values, base, doxygen, attributes, self._current_access
+        )
         self.visitor.on_enum(self.state, enum)
 
         # Finish it up
-        self._finish_class_or_enum(enum.typename, is_typedef, mods, "enum")
+        attrs_after = self._finish_class_or_enum(
+            enum.typename, is_typedef, mods, "enum"
+        )
+        if attrs_after:
+            enum.attributes.extend(attrs_after)
 
     def _parse_enumerator_list(self) -> typing.List[Enumerator]:
         """
@@ -1186,17 +1293,18 @@ class CxxParser:
 
             name = name_tok.value
             value = None
+            attributes = []
 
             tok = self._next_token_must_be("}", ",", "=", "DBL_LBRACKET")
             if tok.type == "DBL_LBRACKET":
-                self._consume_attribute_specifier_seq(tok)
+                attributes = self._consume_attribute_specifier_seq(tok, record=False)
                 tok = self._next_token_must_be("}", ",", "=")
 
             if tok.type == "=":
                 value = self._create_value(self._consume_value_until([], ",", "}"))
                 tok = self._next_token_must_be("}", ",")
 
-            values.append(Enumerator(name, value, doxygen))
+            values.append(Enumerator(name, value, doxygen, attributes))
 
             if tok.type == "}":
                 break
@@ -1235,8 +1343,9 @@ class CxxParser:
             tok_type = tok.type
 
             # might start with attributes
+            attributes = []
             if tok.type in self._attribute_specifier_seq_start_types:
-                self._consume_attribute_specifier_seq(tok)
+                attributes = self._consume_attribute_specifier_seq(tok, record=False)
                 tok = self.lex.token()
                 tok_type = tok.type
 
@@ -1261,7 +1370,9 @@ class CxxParser:
             if self.lex.token_if("ELLIPSIS"):
                 parameter_pack = True
 
-            bases.append(BaseClass(access, typename, virtual, parameter_pack))
+            bases.append(
+                BaseClass(access, typename, virtual, parameter_pack, attributes)
+            )
 
             if not self.lex.token_if(","):
                 break
@@ -1277,6 +1388,7 @@ class CxxParser:
         typedef: bool,
         location: Location,
         mods: ParsedTypeModifiers,
+        attributes: typing.List[Attribute],
     ) -> None:
         """
         class_specifier: class_head "{" [member_specification] "}"
@@ -1329,7 +1441,14 @@ class CxxParser:
             raise self._parse_error(tok, "{")
 
         clsdecl = ClassDecl(
-            typename, bases, template, explicit, final, doxygen, self._current_access
+            typename,
+            bases,
+            template,
+            explicit,
+            final,
+            doxygen,
+            attributes,
+            self._current_access,
         )
         state: ClassBlockState = ClassBlockState(
             self.state, location, clsdecl, default_access, typedef, mods
@@ -1340,12 +1459,14 @@ class CxxParser:
             self.visitor = null_visitor
 
     def _finish_class_decl(self, state: ClassBlockState) -> None:
-        self._finish_class_or_enum(
+        attrs_after = self._finish_class_or_enum(
             state.class_decl.typename,
             state.typedef,
             state.mods,
             state.class_decl.classkey,
         )
+        if attrs_after:
+            state.class_decl.attributes.extend(attrs_after)
 
     def _process_access_specifier(
         self, tok: LexToken, doxygen: typing.Optional[str]
@@ -1433,6 +1554,7 @@ class CxxParser:
         doxygen: typing.Optional[str],
         location: Location,
         is_typedef: bool,
+        attributes: typing.List[Attribute],
     ) -> None:
         state = self.state
         state.location = location
@@ -1498,7 +1620,7 @@ class CxxParser:
         if is_typedef:
             if not name:
                 raise self._parse_error(None)
-            typedef = Typedef(dtype, name, self._current_access)
+            typedef = Typedef(dtype, name, self._current_access, attributes)
             self.visitor.on_typedef(state, typedef)
         else:
             props = dict.fromkeys(mods.both.keys(), True)
@@ -1515,13 +1637,20 @@ class CxxParser:
                     value=default,
                     bits=bits,
                     doxygen=doxygen,
+                    attributes=attributes,
                     **props,
                 )
                 self.visitor.on_class_field(class_state, f)
             else:
                 assert pqname is not None
                 v = Variable(
-                    pqname, dtype, default, doxygen=doxygen, template=template, **props
+                    pqname,
+                    dtype,
+                    default,
+                    doxygen=doxygen,
+                    template=template,
+                    attributes=attributes,
+                    **props,
                 )
                 self.visitor.on_variable(state, v)
 
@@ -2000,6 +2129,10 @@ class CxxParser:
             fn.has_trailing_return = True
             fn.return_type = return_type
 
+        extra_attrs = self._consume_decl_attributes()
+        if extra_attrs:
+            fn.attributes.extend(extra_attrs)
+
         if self.lex.token_if("{"):
             self._discard_contents("{", "}")
             fn.has_body = True
@@ -2073,6 +2206,11 @@ class CxxParser:
                 self.lex.return_token(tok)
                 break
 
+        if not method.has_body:
+            extra_attrs = self._consume_decl_attributes()
+            if extra_attrs:
+                method.attributes.extend(extra_attrs)
+
     def _parse_function(
         self,
         mods: ParsedTypeModifiers,
@@ -2088,6 +2226,7 @@ class CxxParser:
         is_typedef: bool,
         msvc_convention: typing.Optional[LexToken],
         is_guide: bool = False,
+        attributes: typing.Optional[typing.List[Attribute]] = None,
     ) -> bool:
         """
         Assumes the caller has already consumed the return type and name, this consumes the
@@ -2129,6 +2268,11 @@ class CxxParser:
 
         if (is_class_block or multiple_name_segments) and not is_typedef:
             props.update(dict.fromkeys(mods.meths.keys(), True))
+            if mods.explicit_value is not None:
+                props["explicit"] = mods.explicit_value
+
+            if attributes is None:
+                attributes = []
 
             method = Method(
                 return_type,
@@ -2136,6 +2280,7 @@ class CxxParser:
                 params,
                 vararg,
                 doxygen=doxygen,
+                attributes=attributes,
                 constructor=constructor,
                 destructor=destructor,
                 template=template,
@@ -2183,12 +2328,15 @@ class CxxParser:
             return False
         else:
             assert return_type is not None
+            if attributes is None:
+                attributes = []
             fn = Function(
                 return_type,
                 pqname,
                 params,
                 vararg,
                 doxygen=doxygen,
+                attributes=attributes,
                 template=template,
                 operator=op,
                 **props,
@@ -2230,7 +2378,7 @@ class CxxParser:
                     msvc_convention=fn.msvc_convention,
                 )
 
-                typedef = Typedef(fntype, name, self._current_access)
+                typedef = Typedef(fntype, name, self._current_access, attributes or [])
                 self.visitor.on_typedef(state, typedef)
                 return False
             else:
@@ -2416,6 +2564,7 @@ class CxxParser:
         vars: typing.Dict[str, LexToken] = {}  # only found on variables
         both: typing.Dict[str, LexToken] = {}  # found on either
         meths: typing.Dict[str, LexToken] = {}  # only found on methods
+        explicit_value: typing.Optional[Value] = None
 
         get_token = self.lex.token
 
@@ -2424,6 +2573,7 @@ class CxxParser:
 
         pqname: typing.Optional[PQName] = None
         pqname_optional = False
+        friend_tok: typing.Optional[LexToken] = None
 
         _pqname_start_tokens = self._pqname_start_tokens
         _attribute_start = self._attribute_start_tokens
@@ -2448,6 +2598,8 @@ class CxxParser:
                 break
             elif tok_type == "const":
                 const = True
+            elif tok_type == "friend" and pqname is None:
+                friend_tok = tok
             elif tok_type in self._type_kwd_both:
                 if tok_type == "extern":
                     # TODO: store linkage
@@ -2455,6 +2607,13 @@ class CxxParser:
                 both[tok_type] = tok
             elif tok_type in self._type_kwd_meth:
                 meths[tok_type] = tok
+                if tok_type == "explicit":
+                    # C++20: explicit(<bool-constant-expression>)
+                    otok = self.lex.token_if("(")
+                    if otok:
+                        explicit_value = self._create_value(
+                            self._consume_balanced_tokens(otok)[1:-1]
+                        )
             elif tok_type == "mutable":
                 vars["mutable"] = tok
             elif tok_type == "volatile":
@@ -2479,7 +2638,7 @@ class CxxParser:
         self.lex.return_token(tok)
 
         # Always return the modifiers
-        mods = ParsedTypeModifiers(vars, both, meths)
+        mods = ParsedTypeModifiers(vars, both, meths, explicit_value, friend_tok)
         return parsed_type, mods
 
     def _parse_decl(
@@ -2491,6 +2650,7 @@ class CxxParser:
         template: TemplateDeclTypeVar,
         is_typedef: bool,
         is_friend: bool,
+        attributes: typing.List[Attribute],
     ) -> bool:
         toks = []
 
@@ -2596,6 +2756,7 @@ class CxxParser:
                 is_typedef,
                 msvc_convention,
                 is_guide,
+                attributes,
             )
         elif msvc_convention:
             raise self._parse_error(msvc_convention)
@@ -2612,6 +2773,7 @@ class CxxParser:
                 parsed_type.typename,
                 template,
                 doxygen,
+                attributes=attributes,
                 access=self._current_access,
             )
             friend = FriendDecl(cls=fwd)
@@ -2627,7 +2789,9 @@ class CxxParser:
         if isinstance(template, list):
             raise CxxParseError("multiple template declarations on a field")
 
-        self._parse_field(mods, dtype, pqname, template, doxygen, location, is_typedef)
+        self._parse_field(
+            mods, dtype, pqname, template, doxygen, location, is_typedef, attributes
+        )
         return False
 
     def _parse_operator_conversion(
@@ -2638,6 +2802,7 @@ class CxxParser:
         template: TemplateDeclTypeVar,
         is_typedef: bool,
         is_friend: bool,
+        attributes: typing.List[Attribute],
     ) -> None:
         tok = self._next_token_must_be("operator")
 
@@ -2675,6 +2840,8 @@ class CxxParser:
             is_friend,
             False,
             None,
+            False,
+            attributes,
         ):
             # has function body and handled it
             return
@@ -2701,15 +2868,31 @@ class CxxParser:
 
         location = tok.location
 
+        attributes = self._take_pending_attributes()
+
         # Almost always starts out with some kind of type name or a modifier
         parsed_type, mods = self._parse_type(tok, operator_ok=True)
+        attributes.extend(self._take_pending_attributes())
+
+        if mods.friend is not None:
+            if is_friend or is_typedef or not isinstance(self.state, ClassBlockState):
+                raise self._parse_error(mods.friend)
+            is_friend = True
+            mods = mods._replace(friend=None)
 
         # Check to see if this might be a class/enum declaration
         if (
             parsed_type is not None
             and parsed_type.typename.classkey
             and self._maybe_parse_class_enum_decl(
-                parsed_type, mods, doxygen, template, is_typedef, is_friend, location
+                parsed_type,
+                mods,
+                doxygen,
+                template,
+                is_typedef,
+                is_friend,
+                location,
+                attributes,
             )
         ):
             return
@@ -2742,14 +2925,21 @@ class CxxParser:
         if parsed_type is None:
             # this means an operator was encountered, deal with the special case
             self._parse_operator_conversion(
-                mods, location, doxygen, template, is_typedef, is_friend
+                mods, location, doxygen, template, is_typedef, is_friend, attributes
             )
             return
 
         # Ok, dealing with a variable or function/method
         while True:
             if self._parse_decl(
-                parsed_type, mods, location, doxygen, template, is_typedef, is_friend
+                parsed_type,
+                mods,
+                location,
+                doxygen,
+                template,
+                is_typedef,
+                is_friend,
+                attributes,
             ):
                 # if it returns True then it handled the end of the statement
                 break
@@ -2777,6 +2967,7 @@ class CxxParser:
         is_typedef: bool,
         is_friend: bool,
         location: Location,
+        attributes: typing.List[Attribute],
     ) -> bool:
         # check for forward declaration or friend declaration
         if self.lex.token_if(";"):
@@ -2801,7 +2992,11 @@ class CxxParser:
                 raise self._parse_error(None)
 
             fdecl = ForwardDecl(
-                parsed_type.typename, template, doxygen, access=self._current_access
+                parsed_type.typename,
+                template,
+                doxygen,
+                attributes=attributes,
+                access=self._current_access,
             )
             state = self.state
             state.location = location
@@ -2830,14 +3025,21 @@ class CxxParser:
 
             if typename.classkey in ("class", "struct", "union"):
                 self._parse_class_decl(
-                    typename, tok, doxygen, template, is_typedef, location, mods
+                    typename,
+                    tok,
+                    doxygen,
+                    template,
+                    is_typedef,
+                    location,
+                    mods,
+                    attributes,
                 )
             else:
                 if template:
                     # enum cannot have a template
                     raise self._parse_error(tok)
                 self._parse_enum_decl(
-                    typename, tok, doxygen, is_typedef, location, mods
+                    typename, tok, doxygen, is_typedef, location, mods, attributes
                 )
 
             return True
@@ -2851,12 +3053,10 @@ class CxxParser:
         is_typedef: bool,
         mods: ParsedTypeModifiers,
         classkey: typing.Optional[str],
-    ) -> None:
+    ) -> typing.Optional[typing.List[Attribute]]:
         parsed_type = Type(name)
 
-        tok = self.lex.token_if("__attribute__")
-        if tok:
-            self._consume_gcc_attribute(tok)
+        attrs_after = self._consume_decl_attributes()
 
         if not is_typedef and self.lex.token_if(";"):
             # if parent scope is a class, add the anonymous
@@ -2876,12 +3076,12 @@ class CxxParser:
                         access=access,
                     )
                     self.visitor.on_class_field(class_state, f)
-            return
+            return attrs_after
 
         while True:
             location = self.lex.current_location()
             if self._parse_decl(
-                parsed_type, mods, location, None, None, is_typedef, False
+                parsed_type, mods, location, None, None, is_typedef, False, attrs_after
             ):
                 # if it returns True then it handled the end of the statement
                 break
@@ -2890,3 +3090,4 @@ class CxxParser:
             tok = self._next_token_must_be(",", ";")
             if tok.type == ";":
                 break
+        return None

{cxxheaderparser-1.7.0 → cxxheaderparser-1.7.2}/cxxheaderparser/parserstate.py

@@ -5,15 +5,23 @@ if typing.TYPE_CHECKING:
 
 from .errors import CxxParseError
 from .lexer import LexToken, Location
-from .types import ClassDecl, NamespaceDecl
+from .types import ClassDecl, NamespaceDecl, Value
 
 
 class ParsedTypeModifiers(typing.NamedTuple):
     vars: typing.Dict[str, LexToken]  # only found on variables
     both: typing.Dict[str, LexToken]  # found on either variables or functions
     meths: typing.Dict[str, LexToken]  # only found on methods
-
-    def validate(self, *, var_ok: bool, meth_ok: bool, msg: str) -> None:
+    #: For C++20 ``explicit(<expr>)``: the constant expression inside the
+    #: parens (omitting the parens themselves). ``None`` if absent or if
+    #: ``explicit`` was used as a bare keyword.
+    explicit_value: typing.Optional[Value] = None
+    #: ``friend`` if encountered while parsing declaration specifiers.
+    friend: typing.Optional[LexToken] = None
+
+    def validate(
+        self, *, var_ok: bool, meth_ok: bool, msg: str, friend_ok: bool = False
+    ) -> None:
         # Almost there! Do any checks the caller asked for
         if not var_ok and self.vars:
             for tok in self.vars.values():
@@ -27,6 +35,9 @@ class ParsedTypeModifiers(typing.NamedTuple):
             for tok in self.both.values():
                 raise CxxParseError(f"{msg}: unexpected '{tok.value}'")
 
+        if not friend_ok and self.friend is not None:
+            raise CxxParseError(f"{msg}: unexpected '{self.friend.value}'")
+
 
 #: custom user data for this state type
 T = typing.TypeVar("T")

{cxxheaderparser-1.7.0 → cxxheaderparser-1.7.2}/cxxheaderparser/types.py

@@ -1,4 +1,5 @@
 import typing
+from enum import Enum
 from dataclasses import dataclass, field
 
 from .tokfmt import tokfmt, Token
@@ -22,6 +23,41 @@ class Value:
         return tokfmt(self.tokens)
 
 
+class AttributeStyle(Enum):
+    """
+    Indicates what style of attribute was found
+    """
+
+    #: ``[[deprecated]]``
+    CXX = "cxx"
+
+    #: ``__attribute__((deprecated))``
+    GCC = "gcc"
+
+    #: ``__declspec(deprecated)``
+    MSVC = "msvc"
+
+
+@dataclass
+class Attribute:
+    """
+    An attribute
+
+    .. code-block:: c++
+
+        [[deprecated("message")]]
+          ~~~~~~~~~  ~~~~~~~~~~~
+    """
+
+    #: Indicates what style of attribute this is
+    style: AttributeStyle
+
+    name: str
+
+    #: Portion of the attribute inside the parens
+    value: typing.Optional[Value] = None
+
+
 @dataclass
 class NamespaceAlias:
     """
@@ -427,6 +463,9 @@ class Enumerator:
     #: Documentation if present
     doxygen: typing.Optional[str] = None
 
+    #: Any attributes attached to this enumerator
+    attributes: typing.List[Attribute] = field(default_factory=list)
+
 
 @dataclass
 class EnumDecl:
@@ -442,6 +481,8 @@ class EnumDecl:
 
     #: Documentation if present
     doxygen: typing.Optional[str] = None
+    #: Any attributes attached to this enum declaration
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
     #: If within a class, the access level for this decl
     access: typing.Optional[str] = None
@@ -610,6 +651,8 @@ class ForwardDecl:
     typename: PQName
     template: TemplateDeclTypeVar = None
     doxygen: typing.Optional[str] = None
+    #: Any attributes attached to this forward declaration
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
     #: Set if this is a forward declaration of an enum and it has a base
     enum_base: typing.Optional[PQName] = None
@@ -635,6 +678,8 @@ class BaseClass:
 
     #: Contains a ``...``
     param_pack: bool = False
+    #: Any attributes attached to this base specifier
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
 
 @dataclass
@@ -652,6 +697,8 @@ class ClassDecl:
     final: bool = False
 
     doxygen: typing.Optional[str] = None
+    #: Any attributes attached to this class declaration
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
     #: If within a class, the access level for this decl
     access: typing.Optional[str] = None
@@ -701,6 +748,8 @@ class Function:
     vararg: bool = False
 
     doxygen: typing.Optional[str] = None
+    #: Any attributes attached to this function declaration
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
     constexpr: bool = False
     extern: typing.Union[bool, str] = False
@@ -773,7 +822,11 @@ class Method(Function):
     ref_qualifier: typing.Optional[str] = None
 
     constructor: bool = False
-    explicit: bool = False
+
+    #: True if the method was declared ``explicit``. For C++20
+    #: ``explicit(<expr>)``, this holds the expression as a Value (omitting
+    #: the outer parentheses).
+    explicit: typing.Union[bool, Value] = False
     default: bool = False
 
     destructor: bool = False
@@ -825,6 +878,8 @@ class Typedef:
 
     #: If within a class, the access level for this decl
     access: typing.Optional[str] = None
+    #: Any attributes attached to this typedef
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
 
 @dataclass
@@ -847,6 +902,8 @@ class Variable:
     template: typing.Optional[TemplateDecl] = None
 
     doxygen: typing.Optional[str] = None
+    #: Any attributes attached to this variable
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
 
 @dataclass
@@ -870,6 +927,8 @@ class Field:
     inline: bool = False
 
     doxygen: typing.Optional[str] = None
+    #: Any attributes attached to this field
+    attributes: typing.List[Attribute] = field(default_factory=list)
 
 
 @dataclass

cxxheaderparser-1.7.2/cxxheaderparser/version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.7.2'
+__version_tuple__ = version_tuple = (1, 7, 2)
+
+__commit_id__ = commit_id = None

cxxheaderparser-1.7.0/cxxheaderparser/version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '1.7.0'
-__version_tuple__ = version_tuple = (1, 7, 0)
-
-__commit_id__ = commit_id = None