Correctly parse free conversion operators

- Fixes #94
- Fixes #112

Author: virtuald

cxxheaderparser/parser.py

@@ -1925,10 +1925,23 @@ def _parse_pqname(
                     break
 
             # If no more segments, we're done
-            if not self.lex.token_if("DBL_COLON"):
+            tok = self.lex.token_if("DBL_COLON")
+            if not tok:
+                break
+
+            next_tok = self._next_token_must_be(
+                "NAME", "operator", "template", "decltype"
+            )
+            if next_tok.type == "operator" and not fn_ok:
+                # Qualified conversion operators (for example,
+                # ``Foo::operator int()``) do not have a leading return type.
+                # When parsing what might be a type, stop before the operator
+                # so declaration parsing can consume the qualified operator as
+                # the function name and parse the conversion type separately.
+                self.lex.return_tokens([tok, next_tok])
                 break
 
-            tok = self._next_token_must_be("NAME", "operator", "template", "decltype")
+            tok = next_tok
 
         pqname = PQName(segments, classkey, has_typename)
 
@@ -2898,6 +2911,7 @@ def _parse_operator_conversion(
         is_typedef: bool,
         is_friend: bool,
         attributes: typing.List[Attribute],
+        pqname: typing.Optional[PQName] = None,
     ) -> None:
         tok = self._next_token_must_be("operator")
 
@@ -2918,8 +2932,11 @@ def _parse_operator_conversion(
         self._next_token_must_be("(")
 
         # make our own pqname/op here
-        segments: typing.List[PQNameSegment] = [NameSpecifier("operator")]
-        pqname = PQName(segments)
+        if pqname is None:
+            segments: typing.List[PQNameSegment] = [NameSpecifier("operator")]
+            pqname = PQName(segments)
+        else:
+            pqname = PQName([*pqname.segments, NameSpecifier("operator")])
         op = "conversion"
 
         if self._parse_function(
@@ -3024,6 +3041,25 @@ def _parse_declarations(
             )
             return
 
+        qtok = self.lex.token_if("DBL_COLON")
+        if qtok:
+            otok = self.lex.token_if("operator")
+            if otok:
+                self.lex.return_tokens([qtok, otok])
+                self._next_token_must_be("DBL_COLON")
+                self._parse_operator_conversion(
+                    mods,
+                    location,
+                    doxygen,
+                    template,
+                    is_typedef,
+                    is_friend,
+                    attributes,
+                    parsed_type.typename,
+                )
+                return
+            self.lex.return_token(qtok)
+
         # Ok, dealing with a variable or function/method
         while True:
             if self._parse_decl(

tests/test_operators.py

@@ -11,6 +11,10 @@
     PQName,
     Parameter,
     Reference,
+    TemplateArgument,
+    TemplateDecl,
+    TemplateSpecialization,
+    TemplateTypeParam,
     Type,
 )
 from cxxheaderparser.simple import (
@@ -694,6 +698,52 @@ def test_conversion_operators_decorated() -> None:
     )
 
 
+def test_template_conversion_operator_impl() -> None:
+    content = """
+      template <class T> ON_SimpleArray<T>::operator T *() {
+        return (m_count > 0) ? m_a : 0;
+      }
+    """
+    data = parse_string(content, cleandoc=True)
+
+    assert data == ParsedData(
+        namespace=NamespaceScope(
+            method_impls=[
+                Method(
+                    return_type=Pointer(
+                        ptr_to=Type(typename=PQName(segments=[NameSpecifier(name="T")]))
+                    ),
+                    name=PQName(
+                        segments=[
+                            NameSpecifier(
+                                name="ON_SimpleArray",
+                                specialization=TemplateSpecialization(
+                                    args=[
+                                        TemplateArgument(
+                                            arg=Type(
+                                                typename=PQName(
+                                                    segments=[NameSpecifier(name="T")]
+                                                )
+                                            )
+                                        )
+                                    ]
+                                ),
+                            ),
+                            NameSpecifier(name="operator"),
+                        ]
+                    ),
+                    parameters=[],
+                    has_body=True,
+                    template=TemplateDecl(
+                        params=[TemplateTypeParam(typekey="class", name="T")]
+                    ),
+                    operator="conversion",
+                )
+            ]
+        )
+    )
+
+
 def test_free_operator() -> None:
     content = """
       std::ostream& operator<<(std::ostream& os, const MyDate& dt);