IntenseWebs/sphinx
3
0
Fork 0
mirror of https://github.com/sphinx-doc/sphinx.git synced 2025-02-25 18:55:22 -06:00
Code Issues Packages Projects Releases Wiki Activity

C++, internal changes to id generation

Browse Source
This commit is contained in:
Jakob Lykke Andersen 2017-03-21 20:10:41 +09:00
parent 71a1ffb303
commit 85a94b79ca
2 changed files with 582 additions and 732 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

855
sphinx/domains/cpp.py
View File

File diff suppressed because it is too large Load Diff

459
tests/test_domain_cpp.py
View File

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