Merge pull request #148 from robotpy/most-vexing-parse

Fix parenthesized variable initialization

Author: virtuald

cxxheaderparser/parser.py

@@ -1606,7 +1606,7 @@ def _parse_field(
 
         else:
             # default value initializer
-            tok = self.lex.token_if("{")
+            tok = self.lex.token_if("{", "(")
             if tok:
                 if is_typedef:
                     raise self._parse_error(tok)
@@ -2537,6 +2537,22 @@ def _parse_cv_ptr_or_fn(
 
     _parse_type_ptr_ref_paren = {"*", "&", "DBL_AMP", "("}
 
+    _parameter_start_tokens = (
+        _pqname_start_tokens
+        | _attribute_start_tokens
+        | _type_kwd_both
+        | _type_kwd_meth
+        | {
+            "volatile",
+            "mutable",
+            "__inline",
+            "__forceinline",
+            "this",
+            "ELLIPSIS",
+            ")",
+        }
+    )
+
     def _parse_type(
         self,
         tok: typing.Optional[LexToken],
@@ -2735,29 +2751,34 @@ def _parse_decl(
 
         # TODO: "type fn(x);" is ambiguous here. Because this is a header
         # parser, we assume it's a function, not a variable declaration
-        # calling a constructor
+        # calling a constructor, unless the token after ( cannot start a
+        # parameter declaration.
 
-        # if ( then it's a function/method
-        if self.lex.token_if("("):
+        # if ( then it's usually a function/method
+        tok = self.lex.token_if("(")
+        if tok:
             if not pqname:
                 raise self._parse_error(None)
 
-            return self._parse_function(
-                mods,
-                dtype,
-                pqname,
-                op,
-                template,
-                doxygen,
-                location,
-                constructor,
-                destructor,
-                is_friend,
-                is_typedef,
-                msvc_convention,
-                is_guide,
-                attributes,
-            )
+            if not self.lex.token_peek_if(*self._parameter_start_tokens):
+                self.lex.return_token(tok)
+            else:
+                return self._parse_function(
+                    mods,
+                    dtype,
+                    pqname,
+                    op,
+                    template,
+                    doxygen,
+                    location,
+                    constructor,
+                    destructor,
+                    is_friend,
+                    is_typedef,
+                    msvc_convention,
+                    is_guide,
+                    attributes,
+                )
         elif msvc_convention:
             raise self._parse_error(msvc_convention)
 

tests/test_var.py

@@ -601,6 +601,54 @@ def test_var_ns_3() -> None:
     )
 
 
+def test_var_direct_initializer_parens() -> None:
+    content = """
+      const string FOO("foo");
+      int BAR(static_cast<int>(1));
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            variables=[
+                Variable(
+                    name=PQName(segments=[NameSpecifier(name="FOO")]),
+                    type=Type(
+                        typename=PQName(segments=[NameSpecifier(name="string")]),
+                        const=True,
+                    ),
+                    value=Value(
+                        tokens=[
+                            Token(value="("),
+                            Token(value='"foo"'),
+                            Token(value=")"),
+                        ]
+                    ),
+                ),
+                Variable(
+                    name=PQName(segments=[NameSpecifier(name="BAR")]),
+                    type=Type(
+                        typename=PQName(segments=[FundamentalSpecifier(name="int")])
+                    ),
+                    value=Value(
+                        tokens=[
+                            Token(value="("),
+                            Token(value="static_cast"),
+                            Token(value="<"),
+                            Token(value="int"),
+                            Token(value=">"),
+                            Token(value="("),
+                            Token(value="1"),
+                            Token(value=")"),
+                            Token(value=")"),
+                        ]
+                    ),
+                ),
+            ]
+        )
+    )
+
+
 def test_var_static_struct() -> None:
     content = """
       constexpr static struct SS {} s;