C++, internal changes to id generation

1 files changed, 232 insertions, 231 deletions

diff --git a/tests/test_domain_cpp.py b/tests/test_domain_cpp.py
index 446c264fd..e7f12f09c 100644
--- a/tests/test_domain_cpp.py
+++ b/tests/test_domain_cpp.py
@@ -16,11 +16,9 @@ import pytest
 
 from sphinx import addnodes
 from sphinx.domains.cpp import DefinitionParser, DefinitionError, NoOldIdError
-from sphinx.domains.cpp import Symbol
+from sphinx.domains.cpp import Symbol, _max_id, _id_prefix
 import sphinx.domains.cpp as cppDomain
 
-ids = []
-
 
 def parse(name, string):
     class Config(object):
@@ -39,7 +37,7 @@ def parse(name, string):
     return ast
 
 
-def check(name, input, idv1output=None, idv2output=None, output=None):
+def check(name, input, idDict, output=None):
     # first a simple check of the AST
     if output is None:
         output = input
@@ -58,28 +56,35 @@ def check(name, input, idv1output=None, idv2output=None, output=None):
     parentNode += signode
     ast.describe_signature(signode, 'lastIsName', symbol, options={})
 
-    if idv2output:
-        idv2output = "_CPPv2" + idv2output
-    try:
-        idv1 = ast.get_id_v1()
-        assert idv1 is not None
-    except NoOldIdError:
-        idv1 = None
-    try:
-        idv2 = ast.get_id_v2()
-        assert idv2 is not None
-    except NoOldIdError:
-        idv2 = None
-    if idv1 != idv1output or idv2 != idv2output:
+    idExpected = [None]
+    for i in range(1, _max_id + 1):
+        if i in idDict:
+            idExpected.append(idDict[i])
+        else:
+            idExpected.append(idExpected[i - 1])
+    idActual = [None]
+    for i in range(1, _max_id + 1):
+        try:
+            id = ast.get_id(version=i)
+            assert id is not None
+            idActual.append(id[len(_id_prefix[i]):])
+        except NoOldIdError:
+            idActual.append(None)
+
+    res = [True]
+    for i in range(1, _max_id + 1):
+        res.append(idExpected[i] == idActual[i])
+
+    if not all(res):
         print("input:    %s" % text_type(input).rjust(20))
-        print("          %s    %s" % ("Id v1".rjust(20), "Id v2".rjust(20)))
-        print("result:   %s    %s" % (str(idv1).rjust(20), str(idv2).rjust(20)))
-        print("expected: %s    %s" % (str(idv1output).rjust(20),
-                                      str(idv2output).rjust(20)))
+        for i in range(1, _max_id + 1):
+            if res[i]:
+                continue
+            print("Error in id version %d." % i)
+            print("result:   %s" % str(idActual[i]))
+            print("expected: %s" % str(idExpected[i]))
         print(rootSymbol.dump(0))
         raise DefinitionError("")
-    ids.append(ast.get_id_v2())
-    # print ".. %s:: %s" % (name, input)
 
 
 def test_fundamental_types():
@@ -99,55 +104,55 @@ def test_fundamental_types():
             if t == "std::nullptr_t":
                 id = "NSt9nullptr_tE"
             return "1f%s" % id
-        check("function", "void f(%s arg)" % t, makeIdV1(), makeIdV2())
+        check("function", "void f(%s arg)" % t, {1: makeIdV1(), 2:makeIdV2()})
 
 
 def test_type_definitions():
-    check("type", "public bool b", "b", "1b", "bool b")
-    check("type", "bool A::b", "A::b", "N1A1bE")
-    check("type", "bool *b", "b", "1b")
-    check("type", "bool *const b", "b", "1b")
-    check("type", "bool *volatile const b", "b", "1b")
-    check("type", "bool *volatile const b", "b", "1b")
-    check("type", "bool *volatile const *b", "b", "1b")
-    check("type", "bool &b", "b", "1b")
-    check("type", "bool b[]", "b", "1b")
-    check("type", "std::pair<int, int> coord", "coord", "5coord")
-    check("type", "long long int foo", "foo", "3foo")
+    check("type", "public bool b", {1:"b", 2:"1b"}, "bool b")
+    check("type", "bool A::b", {1:"A::b", 2:"N1A1bE"})
+    check("type", "bool *b", {1:"b", 2:"1b"})
+    check("type", "bool *const b", {1:"b", 2:"1b"})
+    check("type", "bool *volatile const b", {1:"b", 2:"1b"})
+    check("type", "bool *volatile const b", {1:"b", 2:"1b"})
+    check("type", "bool *volatile const *b", {1:"b", 2:"1b"})
+    check("type", "bool &b", {1:"b", 2:"1b"})
+    check("type", "bool b[]", {1:"b", 2:"1b"})
+    check("type", "std::pair<int, int> coord", {1:"coord", 2:"5coord"})
+    check("type", "long long int foo", {1:"foo", 2:"3foo"})
     check("type", 'std::vector<std::pair<std::string, long long>> module::blah',
-          "module::blah", "N6module4blahE")
-    check("type", "std::function<void()> F", "F", "1F")
-    check("type", "std::function<R(A1, A2)> F", "F", "1F")
-    check("type", "std::function<R(A1, A2, A3)> F", "F", "1F")
-    check("type", "std::function<R(A1, A2, A3, As...)> F", "F", "1F")
+          {1:"module::blah", 2:"N6module4blahE"})
+    check("type", "std::function<void()> F", {1:"F", 2:"1F"})
+    check("type", "std::function<R(A1, A2)> F", {1:"F", 2:"1F"})
+    check("type", "std::function<R(A1, A2, A3)> F", {1:"F", 2:"1F"})
+    check("type", "std::function<R(A1, A2, A3, As...)> F", {1:"F", 2:"1F"})
     check("type", "MyContainer::const_iterator",
-          "MyContainer::const_iterator", "N11MyContainer14const_iteratorE")
+          {1:"MyContainer::const_iterator", 2:"N11MyContainer14const_iteratorE"})
     check("type",
           "public MyContainer::const_iterator",
-          "MyContainer::const_iterator", "N11MyContainer14const_iteratorE",
+          {1:"MyContainer::const_iterator", 2:"N11MyContainer14const_iteratorE"},
           output="MyContainer::const_iterator")
     # test decl specs on right
-    check("type", "bool const b", "b", "1b")
+    check("type", "bool const b", {1:"b", 2:"1b"})
     # test name in global scope
-    check("type", "bool ::B::b", "B::b", "N1B1bE")
+    check("type", "bool ::B::b", {1:"B::b", 2:"N1B1bE"})
 
-    check('type', 'A = B', None, '1A')
+    check('type', 'A = B', {2:'1A'})
 
     # from breathe#267 (named function parameters for function pointers
     check('type', 'void (*gpio_callback_t)(struct device *port, uint32_t pin)',
-          'gpio_callback_t', '15gpio_callback_t')
-    check('type', 'void (*f)(std::function<void(int i)> g)', 'f', '1f')
+          {1:'gpio_callback_t', 2:'15gpio_callback_t'})
+    check('type', 'void (*f)(std::function<void(int i)> g)', {1:'f', 2:'1f'})
 
 
 def test_concept_definitions():
     check('concept', 'template<typename Param> A::B::Concept',
-          None, 'I0EN1A1B7ConceptE')
+          {2:'I0EN1A1B7ConceptE'})
     check('concept', 'template<typename A, typename B, typename ...C> Foo',
-          None, 'I00DpE3Foo')
+          {2:'I00DpE3Foo'})
     check('concept', 'template<typename Param> A::B::Concept()',
-          None, 'I0EN1A1B7ConceptE')
+          {2:'I0EN1A1B7ConceptE'})
     check('concept', 'template<typename A, typename B, typename ...C> Foo()',
-          None, 'I00DpE3Foo')
+          {2:'I00DpE3Foo'})
     with pytest.raises(DefinitionError):
         parse('concept', 'Foo')
     with pytest.raises(DefinitionError):
@@ -156,256 +161,254 @@ def test_concept_definitions():
 
 def test_member_definitions():
     check('member', '  const  std::string  &  name = 42',
-          "name__ssCR", "4name", output='const std::string &name = 42')
-    check('member', '  const  std::string  &  name', "name__ssCR", "4name",
+          {1:"name__ssCR", 2:"4name"}, output='const std::string &name = 42')
+    check('member', '  const  std::string  &  name', {1:"name__ssCR", 2:"4name"},
           output='const std::string &name')
     check('member', '  const  std::string  &  name [ n ]',
-          "name__ssCRA", "4name", output='const std::string &name[n]')
+          {1:"name__ssCRA", 2:"4name"}, output='const std::string &name[n]')
     check('member', 'const std::vector< unsigned int, long> &name',
-          "name__std::vector:unsigned-i.l:CR",
-          "4name", output='const std::vector<unsigned int, long> &name')
-    check('member', 'module::myclass foo[n]', "foo__module::myclassA", "3foo")
-    check('member', 'int *const p', 'p__iPC', '1p')
-    check('member', 'extern int myInt', 'myInt__i', '5myInt')
-    check('member', 'thread_local int myInt', 'myInt__i', '5myInt')
-    check('member', 'extern thread_local int myInt', 'myInt__i', '5myInt')
-    check('member', 'thread_local extern int myInt', 'myInt__i', '5myInt',
+          {1:"name__std::vector:unsigned-i.l:CR", 2:"4name"},
+          output='const std::vector<unsigned int, long> &name')
+    check('member', 'module::myclass foo[n]', {1:"foo__module::myclassA", 2:"3foo"})
+    check('member', 'int *const p', {1:'p__iPC', 2:'1p'})
+    check('member', 'extern int myInt', {1:'myInt__i', 2:'5myInt'})
+    check('member', 'thread_local int myInt', {1:'myInt__i', 2:'5myInt'})
+    check('member', 'extern thread_local int myInt', {1:'myInt__i', 2:'5myInt'})
+    check('member', 'thread_local extern int myInt', {1:'myInt__i', 2:'5myInt'},
           'extern thread_local int myInt')
 
 
 def test_function_definitions():
-    check('function', 'operator bool() const', "castto-b-operatorC", "NKcvbEv")
+    check('function', 'operator bool() const', {1:"castto-b-operatorC", 2:"NKcvbEv"})
     check('function', 'A::operator bool() const',
-          "A::castto-b-operatorC", "NK1AcvbEv")
+          {1:"A::castto-b-operatorC", 2:"NK1AcvbEv"})
     check('function', 'A::operator bool() volatile const &',
-          "A::castto-b-operatorVCR", "NVKR1AcvbEv")
+          {1:"A::castto-b-operatorVCR", 2:"NVKR1AcvbEv"})
     check('function', 'A::operator bool() volatile const &&',
-          "A::castto-b-operatorVCO", "NVKO1AcvbEv")
+          {1:"A::castto-b-operatorVCO", 2:"NVKO1AcvbEv"})
     check('function', 'bool namespaced::theclass::method(arg1, arg2)',
-          "namespaced::theclass::method__arg1.arg2",
-          "N10namespaced8theclass6methodE4arg14arg2")
+          {1:"namespaced::theclass::method__arg1.arg2",
+          2:"N10namespaced8theclass6methodE4arg14arg2"})
     x = 'std::vector<std::pair<std::string, int>> &module::test(register int ' \
         'foo, bar, std::string baz = "foobar, blah, bleh") const = 0'
-    check('function', x, "module::test__i.bar.ssC",
-          "NK6module4testEi3barNSt6stringE")
+    check('function', x, {1:"module::test__i.bar.ssC",
+          2:"NK6module4testEi3barNSt6stringE"})
     check('function', 'void f(std::pair<A, B>)',
-          "f__std::pair:A.B:", "1fNSt4pairI1A1BEE")
+          {1:"f__std::pair:A.B:", 2:"1fNSt4pairI1A1BEE"})
     check('function', 'explicit module::myclass::foo::foo()',
-          "module::myclass::foo::foo", "N6module7myclass3foo3fooEv")
+          {1:"module::myclass::foo::foo", 2:"N6module7myclass3foo3fooEv"})
     check('function', 'module::myclass::foo::~foo()',
-          "module::myclass::foo::~foo", "N6module7myclass3fooD0Ev")
+          {1:"module::myclass::foo::~foo", 2:"N6module7myclass3fooD0Ev"})
     check('function', 'int printf(const char *fmt, ...)',
-          "printf__cCP.z", "6printfPKcz")
+          {1:"printf__cCP.z", 2:"6printfPKcz"})
     check('function', 'int foo(const unsigned int j)',
-          "foo__unsigned-iC", "3fooKj")
+          {1:"foo__unsigned-iC", 2:"3fooKj"})
     check('function', 'int foo(const int *const ptr)',
-          "foo__iCPC", "3fooPCKi")
+          {1:"foo__iCPC", 2:"3fooPCKi"})
     check('function', 'module::myclass::operator std::vector<std::string>()',
-          "module::myclass::castto-std::vector:ss:-operator",
-          "N6module7myclasscvNSt6vectorINSt6stringEEEEv")
+          {1:"module::myclass::castto-std::vector:ss:-operator",
+          2:"N6module7myclasscvNSt6vectorINSt6stringEEEEv"})
     check('function',
           'void operator()(const boost::array<VertexID, 2> &v) const',
-          "call-operator__boost::array:VertexID.2:CRC",
-          "NKclERKN5boost5arrayI8VertexIDX2EEE")
+          {1:"call-operator__boost::array:VertexID.2:CRC",
+          2:"NKclERKN5boost5arrayI8VertexIDX2EEE"})
     check('function',
           'void operator()(const boost::array<VertexID, 2, "foo,  bar"> &v) const',
-          'call-operator__boost::array:VertexID.2."foo,--bar":CRC',
-          'NKclERKN5boost5arrayI8VertexIDX2EX"foo,  bar"EEE')
+          {1:'call-operator__boost::array:VertexID.2."foo,--bar":CRC',
+          2:'NKclERKN5boost5arrayI8VertexIDX2EX"foo,  bar"EEE'})
     check('function', 'MyClass::MyClass(MyClass::MyClass&&)',
-          "MyClass::MyClass__MyClass::MyClassRR",
-          "N7MyClass7MyClassERRN7MyClass7MyClassE")
-    check('function', 'constexpr int get_value()', "get_valueCE", "9get_valuev")
+          {1:"MyClass::MyClass__MyClass::MyClassRR",
+          2:"N7MyClass7MyClassERRN7MyClass7MyClassE"})
+    check('function', 'constexpr int get_value()', {1:"get_valueCE", 2:"9get_valuev"})
     check('function', 'static constexpr int get_value()',
-          "get_valueCE", "9get_valuev")
+          {1:"get_valueCE", 2:"9get_valuev"})
     check('function', 'int get_value() const noexcept',
-          "get_valueC", "NK9get_valueEv")
+          {1:"get_valueC", 2:"NK9get_valueEv"})
     check('function', 'int get_value() const noexcept = delete',
-          "get_valueC", "NK9get_valueEv")
+          {1:"get_valueC", 2:"NK9get_valueEv"})
     check('function', 'int get_value() volatile const',
-          "get_valueVC", "NVK9get_valueEv")
+          {1:"get_valueVC", 2:"NVK9get_valueEv"})
     check('function', 'MyClass::MyClass(MyClass::MyClass&&) = default',
-          "MyClass::MyClass__MyClass::MyClassRR",
-          "N7MyClass7MyClassERRN7MyClass7MyClassE")
+          {1:"MyClass::MyClass__MyClass::MyClassRR",
+          2:"N7MyClass7MyClassERRN7MyClass7MyClassE"})
     check('function', 'virtual MyClass::a_virtual_function() const override',
-          "MyClass::a_virtual_functionC", "NK7MyClass18a_virtual_functionEv")
-    check('function', 'A B() override', "B", "1Bv")
-    check('function', 'A B() final', "B", "1Bv")
-    check('function', 'A B() final override', "B", "1Bv")
-    check('function', 'A B() override final', "B", "1Bv",
+          {1:"MyClass::a_virtual_functionC", 2:"NK7MyClass18a_virtual_functionEv"})
+    check('function', 'A B() override', {1:"B", 2:"1Bv"})
+    check('function', 'A B() final', {1:"B", 2:"1Bv"})
+    check('function', 'A B() final override', {1:"B", 2:"1Bv"})
+    check('function', 'A B() override final', {1:"B", 2:"1Bv"},
           output='A B() final override')
     check('function', 'MyClass::a_member_function() volatile',
-          "MyClass::a_member_functionV", "NV7MyClass17a_member_functionEv")
+          {1:"MyClass::a_member_functionV", 2:"NV7MyClass17a_member_functionEv"})
     check('function', 'MyClass::a_member_function() volatile const',
-          "MyClass::a_member_functionVC", "NVK7MyClass17a_member_functionEv")
+          {1:"MyClass::a_member_functionVC", 2:"NVK7MyClass17a_member_functionEv"})
     check('function', 'MyClass::a_member_function() &&',
-          "MyClass::a_member_functionO", "NO7MyClass17a_member_functionEv")
+          {1:"MyClass::a_member_functionO", 2:"NO7MyClass17a_member_functionEv"})
     check('function', 'MyClass::a_member_function() &',
-          "MyClass::a_member_functionR", "NR7MyClass17a_member_functionEv")
+          {1:"MyClass::a_member_functionR", 2:"NR7MyClass17a_member_functionEv"})
     check('function', 'MyClass::a_member_function() const &',
-          "MyClass::a_member_functionCR", "NKR7MyClass17a_member_functionEv")
+          {1:"MyClass::a_member_functionCR", 2:"NKR7MyClass17a_member_functionEv"})
     check('function', 'int main(int argc, char *argv[])',
-          "main__i.cPA", "4mainiA_Pc")
+          {1:"main__i.cPA", 2:"4mainiA_Pc"})
     check('function', 'MyClass &MyClass::operator++()',
-          "MyClass::inc-operator", "N7MyClassppEv")
+          {1:"MyClass::inc-operator", 2:"N7MyClassppEv"})
     check('function', 'MyClass::pointer MyClass::operator->()',
-          "MyClass::pointer-operator", "N7MyClassptEv")
+          {1:"MyClass::pointer-operator", 2:"N7MyClassptEv"})
 
     x = 'std::vector<std::pair<std::string, int>> &module::test(register int ' \
         'foo, bar[n], std::string baz = "foobar, blah, bleh") const = 0'
-    check('function', x, "module::test__i.barA.ssC",
-          "NK6module4testEiAn_3barNSt6stringE")
+    check('function', x, {1:"module::test__i.barA.ssC",
+          2:"NK6module4testEiAn_3barNSt6stringE"})
     check('function',
           'int foo(Foo f = Foo(double(), std::make_pair(int(2), double(3.4))))',
-          "foo__Foo", "3foo3Foo")
-    check('function', 'int foo(A a = x(a))', "foo__A", "3foo1A")
+          {1:"foo__Foo", 2:"3foo3Foo"})
+    check('function', 'int foo(A a = x(a))', {1:"foo__A", 2:"3foo1A"})
     with pytest.raises(DefinitionError):
         parse('function', 'int foo(B b=x(a)')
     with pytest.raises(DefinitionError):
         parse('function', 'int foo)C c=x(a))')
     with pytest.raises(DefinitionError):
         parse('function', 'int foo(D d=x(a')
-    check('function', 'int foo(const A&... a)', "foo__ACRDp", "3fooDpRK1A")
-    check('function', 'virtual void f()', "f", "1fv")
+    check('function', 'int foo(const A&... a)', {1:"foo__ACRDp", 2:"3fooDpRK1A"})
+    check('function', 'virtual void f()', {1:"f", 2:"1fv"})
     # test for ::nestedName, from issue 1738
     check("function", "result(int val, ::std::error_category const &cat)",
-          "result__i.std::error_categoryCR", "6resultiRNSt14error_categoryE")
-    check("function", "int *f()", "f", "1fv")
+          {1:"result__i.std::error_categoryCR", 2:"6resultiRNSt14error_categoryE"})
+    check("function", "int *f()", {1:"f", 2:"1fv"})
     # tests derived from issue #1753 (skip to keep sanity)
-    check("function", "f(int (&array)[10])", None, "1fRA10_i")
-    check("function", "void f(int (&array)[10])", None, "1fRA10_i")
-    check("function", "void f(float *q(double))", None, "1fFPfdE")
-    check("function", "void f(float *(*q)(double))", None, "1fPFPfdE")
-    check("function", "void f(float (*q)(double))", None, "1fPFfdE")
-    check("function", "int (*f(double d))(float)", "f__double", "1fd")
-    check("function", "int (*f(bool b))[5]", "f__b", "1fb")
+    check("function", "f(int (&array)[10])", {2:"1fRA10_i"})
+    check("function", "void f(int (&array)[10])", {2:"1fRA10_i"})
+    check("function", "void f(float *q(double))", {2:"1fFPfdE"})
+    check("function", "void f(float *(*q)(double))", {2:"1fPFPfdE"})
+    check("function", "void f(float (*q)(double))", {2:"1fPFfdE"})
+    check("function", "int (*f(double d))(float)", {1:"f__double", 2:"1fd"})
+    check("function", "int (*f(bool b))[5]", {1:"f__b", 2:"1fb"})
     check("function", "int (*A::f(double d) const)(float)",
-          "A::f__doubleC", "NK1A1fEd")
+          {1:"A::f__doubleC", 2:"NK1A1fEd"})
     check("function", "void f(std::shared_ptr<int(double)> ptr)",
-          None, "1fNSt10shared_ptrIFidEEE")
-    check("function", "void f(int *const p)", "f__iPC", "1fPCi")
-    check("function", "void f(int *volatile const p)", "f__iPVC", "1fPVCi")
+          {2:"1fNSt10shared_ptrIFidEEE"})
+    check("function", "void f(int *const p)", {1:"f__iPC", 2:"1fPCi"})
+    check("function", "void f(int *volatile const p)", {1:"f__iPVC", 2:"1fPVCi"})
 
-    check('function', 'extern int f()', 'f', '1fv')
+    check('function', 'extern int f()', {1:'f', 2:'1fv'})
 
     # TODO: make tests for functions in a template, e.g., Test<int&&()>
     # such that the id generation for function type types is correct.
 
     check('function', 'friend std::ostream &f(std::ostream&, int)',
-          'f__osR.i', '1fRNSt7ostreamEi')
+          {1:'f__osR.i', 2:'1fRNSt7ostreamEi'})
 
     # from breathe#223
-    check('function', 'void f(struct E e)', 'f__E', '1f1E')
-    check('function', 'void f(class E e)', 'f__E', '1f1E')
-    check('function', 'void f(typename E e)', 'f__E', '1f1E')
-    check('function', 'void f(enum E e)', 'f__E', '1f1E')
-    check('function', 'void f(union E e)', 'f__E', '1f1E')
+    check('function', 'void f(struct E e)', {1:'f__E', 2:'1f1E'})
+    check('function', 'void f(class E e)', {1:'f__E', 2:'1f1E'})
+    check('function', 'void f(typename E e)', {1:'f__E', 2:'1f1E'})
+    check('function', 'void f(enum E e)', {1:'f__E', 2:'1f1E'})
+    check('function', 'void f(union E e)', {1:'f__E', 2:'1f1E'})
 
     # pointer to member (function)
-    check('function', 'void f(int C::*)', None, '1fM1Ci')
-    check('function', 'void f(int C::* p)', None, '1fM1Ci')
-    check('function', 'void f(int ::C::* p)', None, '1fM1Ci')
-    check('function', 'void f(int C::* const)', None, '1fKM1Ci')
-    check('function', 'void f(int C::* const&)', None, '1fRKM1Ci')
-    check('function', 'void f(int C::* volatile)', None, '1fVM1Ci')
-    check('function', 'void f(int C::* const volatile)', None, '1fVKM1Ci',
+    check('function', 'void f(int C::*)', {2:'1fM1Ci'})
+    check('function', 'void f(int C::* p)', {2:'1fM1Ci'})
+    check('function', 'void f(int ::C::* p)', {2:'1fM1Ci'})
+    check('function', 'void f(int C::* const)', {2:'1fKM1Ci'})
+    check('function', 'void f(int C::* const&)', {2:'1fRKM1Ci'})
+    check('function', 'void f(int C::* volatile)', {2:'1fVM1Ci'})
+    check('function', 'void f(int C::* const volatile)', {2:'1fVKM1Ci'},
           output='void f(int C::* volatile const)')
-    check('function', 'void f(int C::* volatile const)', None, '1fVKM1Ci')
-    check('function', 'void f(int (C::*)(float, double))', None, '1fM1CFifdE')
-    check('function', 'void f(int (C::* p)(float, double))', None, '1fM1CFifdE')
-    check('function', 'void f(int (::C::* p)(float, double))', None, '1fM1CFifdE')
-    check('function', 'void f(void (C::*)() const &)', None, '1fM1CKRFvvE')
-    check('function', 'int C::* f(int, double)', None, '1fid')
-    check('function', 'void f(int C::* *)', None, '1fPM1Ci')
+    check('function', 'void f(int C::* volatile const)', {2:'1fVKM1Ci'})
+    check('function', 'void f(int (C::*)(float, double))', {2:'1fM1CFifdE'})
+    check('function', 'void f(int (C::* p)(float, double))', {2:'1fM1CFifdE'})
+    check('function', 'void f(int (::C::* p)(float, double))', {2:'1fM1CFifdE'})
+    check('function', 'void f(void (C::*)() const &)', {2:'1fM1CKRFvvE'})
+    check('function', 'int C::* f(int, double)', {2:'1fid'})
+    check('function', 'void f(int C::* *)', {2:'1fPM1Ci'})
 
 
 def test_operators():
     check('function', 'void operator new [  ] ()',
-          "new-array-operator", "nav", output='void operator new[]()')
+          {1:"new-array-operator", 2:"nav"}, output='void operator new[]()')
     check('function', 'void operator delete ()',
-          "delete-operator", "dlv", output='void operator delete()')
+          {1:"delete-operator", 2:"dlv"}, output='void operator delete()')
     check('function', 'operator bool() const',
-          "castto-b-operatorC", "NKcvbEv", output='operator bool() const')
+          {1:"castto-b-operatorC", 2:"NKcvbEv"}, output='operator bool() const')
 
     check('function', 'void operator * ()',
-          "mul-operator", "mlv", output='void operator*()')
+          {1:"mul-operator", 2:"mlv"}, output='void operator*()')
     check('function', 'void operator - ()',
-          "sub-operator", "miv", output='void operator-()')
+          {1:"sub-operator", 2:"miv"}, output='void operator-()')
     check('function', 'void operator + ()',
-          "add-operator", "plv", output='void operator+()')
+          {1:"add-operator", 2:"plv"}, output='void operator+()')
     check('function', 'void operator = ()',
-          "assign-operator", "aSv", output='void operator=()')
+          {1:"assign-operator", 2:"aSv"}, output='void operator=()')
     check('function', 'void operator / ()',
-          "div-operator", "dvv", output='void operator/()')
+          {1:"div-operator", 2:"dvv"}, output='void operator/()')
     check('function', 'void operator % ()',
-          "mod-operator", "rmv", output='void operator%()')
+          {1:"mod-operator", 2:"rmv"}, output='void operator%()')
     check('function', 'void operator ! ()',
-          "not-operator", "ntv", output='void operator!()')
+          {1:"not-operator", 2:"ntv"}, output='void operator!()')
 
     check('function', 'void operator "" _udl()',
-          None, 'li4_udlv', output='void operator""_udl()')
+          {2:'li4_udlv'}, output='void operator""_udl()')
 
 
 def test_class_definitions():
-    check('class', 'public A', "A", "1A", output='A')
-    check('class', 'private A', "A", "1A")
-    check('class', 'A final', 'A', '1A')
+    check('class', 'public A', {1:"A", 2:"1A"}, output='A')
+    check('class', 'private A', {1:"A", 2:"1A"})
+    check('class', 'A final', {1:'A', 2:'1A'})
 
     # test bases
-    check('class', 'A', "A", "1A")
-    check('class', 'A::B::C', "A::B::C", "N1A1B1CE")
-    check('class', 'A : B', "A", "1A")
-    check('class', 'A : private B', "A", "1A", output='A : B')
-    check('class', 'A : public B', "A", "1A")
-    check('class', 'A : B, C', "A", "1A")
-    check('class', 'A : B, protected C, D', "A", "1A")
-    check('class', 'A : virtual private B', 'A', '1A', output='A : virtual B')
-    check('class', 'A : B, virtual C', 'A', '1A')
-    check('class', 'A : public virtual B', 'A', '1A')
-    check('class', 'A : B, C...', 'A', '1A')
-    check('class', 'A : B..., C', 'A', '1A')
+    check('class', 'A', {1:"A", 2:"1A"})
+    check('class', 'A::B::C', {1:"A::B::C", 2:"N1A1B1CE"})
+    check('class', 'A : B', {1:"A", 2:"1A"})
+    check('class', 'A : private B', {1:"A", 2:"1A"}, output='A : B')
+    check('class', 'A : public B', {1:"A", 2:"1A"})
+    check('class', 'A : B, C', {1:"A", 2:"1A"})
+    check('class', 'A : B, protected C, D', {1:"A", 2:"1A"})
+    check('class', 'A : virtual private B', {1:'A', 2:'1A'}, output='A : virtual B')
+    check('class', 'A : B, virtual C', {1:'A', 2:'1A'})
+    check('class', 'A : public virtual B', {1:'A', 2:'1A'})
+    check('class', 'A : B, C...', {1:'A', 2:'1A'})
+    check('class', 'A : B..., C', {1:'A', 2:'1A'})
 
 
 def test_enum_definitions():
-    check('enum', 'A', None, "1A")
-    check('enum', 'A : std::underlying_type<B>::type', None, "1A")
-    check('enum', 'A : unsigned int', None, "1A")
-    check('enum', 'public A', None, "1A", output='A')
-    check('enum', 'private A', None, "1A")
+    check('enum', 'A', {2:"1A"})
+    check('enum', 'A : std::underlying_type<B>::type', {2:"1A"})
+    check('enum', 'A : unsigned int', {2:"1A"})
+    check('enum', 'public A', {2:"1A"}, output='A')
+    check('enum', 'private A', {2:"1A"})
 
-    check('enumerator', 'A', None, "1A")
-    check('enumerator', 'A = std::numeric_limits<unsigned long>::max()',
-          None, "1A")
+    check('enumerator', 'A', {2:"1A"})
+    check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2:"1A"})
 
 
 def test_templates():
-    check('class', "A<T>", None, "IE1AI1TE", output="template<> A<T>")
+    check('class', "A<T>", {2:"IE1AI1TE"}, output="template<> A<T>")
     # first just check which objects support templating
-    check('class', "template<> A", None, "IE1A")
-    check('function', "template<> void A()", None, "IE1Av")
-    check('member', "template<> A a", None, "IE1a")
-    check('type', "template<> a = A", None, "IE1a")
+    check('class', "template<> A", {2:"IE1A"})
+    check('function', "template<> void A()", {2:"IE1Av"})
+    check('member', "template<> A a", {2:"IE1a"})
+    check('type', "template<> a = A", {2:"IE1a"})
     with pytest.raises(DefinitionError):
         parse('enum', "template<> A")
     with pytest.raises(DefinitionError):
         parse('enumerator', "template<> A")
     # then all the real tests
-    check('class', "template<typename T1, typename T2> A", None, "I00E1A")
-    check('type', "template<> a", None, "IE1a")
-
-    check('class', "template<typename T> A", None, "I0E1A")
-    check('class', "template<class T> A", None, "I0E1A")
-    check('class', "template<typename ...T> A", None, "IDpE1A")
-    check('class', "template<typename...> A", None, "IDpE1A")
-    check('class', "template<typename = Test> A", None, "I0E1A")
-    check('class', "template<typename T = Test> A", None, "I0E1A")
-
-    check('class', "template<template<typename> typename T> A",
-          None, "II0E0E1A")
-    check('class', "template<int> A", None, "I_iE1A")
-    check('class', "template<int T> A", None, "I_iE1A")
-    check('class', "template<int... T> A", None, "I_DpiE1A")
-    check('class', "template<int T = 42> A", None, "I_iE1A")
-    check('class', "template<int = 42> A", None, "I_iE1A")
+    check('class', "template<typename T1, typename T2> A", {2:"I00E1A"})
+    check('type', "template<> a", {2:"IE1a"})
+
+    check('class', "template<typename T> A", {2:"I0E1A"})
+    check('class', "template<class T> A", {2:"I0E1A"})
+    check('class', "template<typename ...T> A", {2:"IDpE1A"})
+    check('class', "template<typename...> A", {2:"IDpE1A"})
+    check('class', "template<typename = Test> A", {2:"I0E1A"})
+    check('class', "template<typename T = Test> A", {2:"I0E1A"})
+
+    check('class', "template<template<typename> typename T> A", {2:"II0E0E1A"})
+    check('class', "template<int> A", {2:"I_iE1A"})
+    check('class', "template<int T> A", {2:"I_iE1A"})
+    check('class', "template<int... T> A", {2:"I_DpiE1A"})
+    check('class', "template<int T = 42> A", {2:"I_iE1A"})
+    check('class', "template<int = 42> A", {2:"I_iE1A"})
 
     # from #2058
     check('function',
@@ -413,8 +416,8 @@ def test_templates():
           "inline std::basic_ostream<Char, Traits> &operator<<("
           "std::basic_ostream<Char, Traits> &os, "
           "const c_string_view_base<const Char, Traits> &str)",
-          None, "I00ElsRNSt13basic_ostreamI4Char6TraitsEE"
-          "RK18c_string_view_baseIK4Char6TraitsE")
+          {2:"I00ElsRNSt13basic_ostreamI4Char6TraitsEE"
+          "RK18c_string_view_baseIK4Char6TraitsE"})
 
     # template introductions
     with pytest.raises(DefinitionError):
@@ -422,63 +425,61 @@ def test_templates():
     with pytest.raises(DefinitionError):
         parse('enumerator', 'abc::ns::foo{id_0, id_1, id_2} A')
     check('class', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar',
-          None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE')
+          {2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
     check('class', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar',
-          None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE')
+          {2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
     check('class', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar<id_0, id_1, id_2>',
-          None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barI4id_04id_14id_2EE')
+          {2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barI4id_04id_14id_2EE'})
     check('class', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar<id_0, id_1, id_2...>',
-          None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barI4id_04id_1Dp4id_2EE')
+          {2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barI4id_04id_1Dp4id_2EE'})
 
-    check('class', 'template<> Concept{U} A<int>::B',
-          None, 'IEI0EX7ConceptI1UEEN1AIiE1BE')
+    check('class', 'template<> Concept{U} A<int>::B', {2:'IEI0EX7ConceptI1UEEN1AIiE1BE'})
 
     check('type', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar = ghi::qux',
-          None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE')
+          {2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
     check('type', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar = ghi::qux',
-          None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE')
+          {2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
     check('function', 'abc::ns::foo{id_0, id_1, id_2} void xyz::bar()',
-          None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barEv')
+          {2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barEv'})
     check('function', 'abc::ns::foo{id_0, id_1, ...id_2} void xyz::bar()',
-          None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barEv')
+          {2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barEv'})
     check('member', 'abc::ns::foo{id_0, id_1, id_2} ghi::qux xyz::bar',
-          None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE')
+          {2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
     check('member', 'abc::ns::foo{id_0, id_1, ...id_2} ghi::qux xyz::bar',
-          None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE')
-    check('concept', 'Iterator{T, U} Another',
-          None, 'I00EX8IteratorI1T1UEE7Another')
+          {2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
+    check('concept', 'Iterator{T, U} Another', {2:'I00EX8IteratorI1T1UEE7Another'})
     check('concept', 'template<typename ...Pack> Numerics = (... && Numeric<Pack>)',
-          None, 'IDpE8Numerics')
+          {2:'IDpE8Numerics'})
 
 def test_template_args():
     # from breathe#218
     check('function',
           "template<typename F> "
           "void allow(F *f, typename func<F, B, G!=1>::type tt)",
-          None, "I0E5allowP1FN4funcI1F1BXG!=1EE4typeE")
+          {2:"I0E5allowP1FN4funcI1F1BXG!=1EE4typeE"})
     # from #3542
     check('type', "template<typename T> "
           "enable_if_not_array_t = std::enable_if_t<!is_array<T>::value, int>",
-          None, "I0E21enable_if_not_array_t")
+          {2:"I0E21enable_if_not_array_t"})
 
 def test_attributes():
     # style: C++
-    check('member', '[[]] int f', 'f__i', '1f')
-    check('member', '[ [ ] ] int f', 'f__i', '1f',
+    check('member', '[[]] int f', {1:'f__i', 2:'1f'})
+    check('member', '[ [ ] ] int f', {1:'f__i', 2:'1f'},
           # this will fail when the proper grammar is implemented
           output='[[ ]] int f')
-    check('member', '[[a]] int f', 'f__i', '1f')
+    check('member', '[[a]] int f', {1:'f__i', 2:'1f'})
     # style: GNU
-    check('member', '__attribute__(()) int f', 'f__i', '1f')
-    check('member', '__attribute__((a)) int f', 'f__i', '1f')
-    check('member', '__attribute__((a, b)) int f', 'f__i', '1f')
+    check('member', '__attribute__(()) int f', {1:'f__i', 2:'1f'})
+    check('member', '__attribute__((a)) int f', {1:'f__i', 2:'1f'})
+    check('member', '__attribute__((a, b)) int f', {1:'f__i', 2:'1f'})
     # style: user-defined id
-    check('member', 'id_attr int f', 'f__i', '1f')
+    check('member', 'id_attr int f', {1:'f__i', 2:'1f'})
     # style: user-defined paren
-    check('member', 'paren_attr() int f', 'f__i', '1f')
-    check('member', 'paren_attr(a) int f', 'f__i', '1f')
-    check('member', 'paren_attr("") int f', 'f__i', '1f')
-    check('member', 'paren_attr(()[{}][]{}) int f', 'f__i', '1f')
+    check('member', 'paren_attr() int f', {1:'f__i', 2:'1f'})
+    check('member', 'paren_attr(a) int f', {1:'f__i', 2:'1f'})
+    check('member', 'paren_attr("") int f', {1:'f__i', 2:'1f'})
+    check('member', 'paren_attr(()[{}][]{}) int f', {1:'f__i', 2:'1f'})
     with pytest.raises(DefinitionError):
         parse('member', 'paren_attr(() int f')
     with pytest.raises(DefinitionError):
@@ -494,7 +495,7 @@ def test_attributes():
 
     # position: decl specs
     check('function', 'static inline __attribute__(()) void f()',
-          'f', '1fv',
+          {1:'f', 2:'1fv'},
           output='__attribute__(()) static inline void f()')