Add support for explicit-expressions. Fixes #139

Author: kdkavanagh

cxxheaderparser/parser.py

@@ -2268,6 +2268,8 @@ def _parse_function(
 
         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 = []
@@ -2562,6 +2564,7 @@ def _parse_type(
         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
 
@@ -2601,6 +2604,13 @@ def _parse_type(
                 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":
@@ -2625,7 +2635,7 @@ def _parse_type(
         self.lex.return_token(tok)
 
         # Always return the modifiers
-        mods = ParsedTypeModifiers(vars, both, meths)
+        mods = ParsedTypeModifiers(vars, both, meths, explicit_value)
         return parsed_type, mods
 
     def _parse_decl(

cxxheaderparser/parserstate.py

@@ -5,13 +5,17 @@
 
 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
+    #: 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
 
     def validate(self, *, var_ok: bool, meth_ok: bool, msg: str) -> None:
         # Almost there! Do any checks the caller asked for

cxxheaderparser/types.py

@@ -822,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

tests/test_class.py

@@ -2308,6 +2308,106 @@ class Lizzard {
     )
 
 
+def test_class_fn_explicit_bool_constructor() -> None:
+    # C++20: explicit(<bool-constant-expression>)
+    content = """
+      struct Clazz {
+        explicit(false) Clazz();
+        explicit(sizeof(int) == 4) Clazz(int a);
+        template<class U>
+        explicit(!std::is_convertible_v<U, Clazz>)
+        Clazz(U const& u);
+      };
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            classes=[
+                ClassScope(
+                    class_decl=ClassDecl(
+                        typename=PQName(
+                            segments=[NameSpecifier(name="Clazz")], classkey="struct"
+                        )
+                    ),
+                    methods=[
+                        Method(
+                            return_type=None,
+                            name=PQName(segments=[NameSpecifier(name="Clazz")]),
+                            parameters=[],
+                            access="public",
+                            constructor=True,
+                            explicit=Value(tokens=[Token(value="false")]),
+                        ),
+                        Method(
+                            return_type=None,
+                            name=PQName(segments=[NameSpecifier(name="Clazz")]),
+                            parameters=[
+                                Parameter(
+                                    type=Type(
+                                        typename=PQName(
+                                            segments=[FundamentalSpecifier(name="int")]
+                                        )
+                                    ),
+                                    name="a",
+                                )
+                            ],
+                            access="public",
+                            constructor=True,
+                            explicit=Value(
+                                tokens=[
+                                    Token(value="sizeof"),
+                                    Token(value="("),
+                                    Token(value="int"),
+                                    Token(value=")"),
+                                    Token(value="="),
+                                    Token(value="="),
+                                    Token(value="4"),
+                                ]
+                            ),
+                        ),
+                        Method(
+                            return_type=None,
+                            name=PQName(segments=[NameSpecifier(name="Clazz")]),
+                            parameters=[
+                                Parameter(
+                                    type=Reference(
+                                        ref_to=Type(
+                                            typename=PQName(
+                                                segments=[NameSpecifier(name="U")]
+                                            ),
+                                            const=True,
+                                        )
+                                    ),
+                                    name="u",
+                                )
+                            ],
+                            access="public",
+                            constructor=True,
+                            template=TemplateDecl(
+                                params=[TemplateTypeParam(typekey="class", name="U")]
+                            ),
+                            explicit=Value(
+                                tokens=[
+                                    Token(value="!"),
+                                    Token(value="std"),
+                                    Token(value="::"),
+                                    Token(value="is_convertible_v"),
+                                    Token(value="<"),
+                                    Token(value="U"),
+                                    Token(value=","),
+                                    Token(value="Clazz"),
+                                    Token(value=">"),
+                                ]
+                            ),
+                        ),
+                    ],
+                )
+            ]
+        )
+    )
+
+
 def test_class_fn_default_constructor() -> None:
     content = """
       class DefaultConstDest {