From 4d2903e63089f20c997b166225da396babd9bcab Mon Sep 17 00:00:00 2001 From: kpnr Date: Mon, 9 Dec 2019 15:59:05 +0300 Subject: [PATCH 01/22] Non-ASCII & non utf-8 charset corruption fix Prefer native loader against fileIO --- sphinx/util/__init__.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/sphinx/util/__init__.py b/sphinx/util/__init__.py index 19ffec633..62f36cc0b 100644 --- a/sphinx/util/__init__.py +++ b/sphinx/util/__init__.py @@ -277,18 +277,17 @@ def get_module_source(modname: str) -> Tuple[str, str]: raise PycodeError('error importing %r' % modname, err) filename = getattr(mod, '__file__', None) loader = getattr(mod, '__loader__', None) + try: # prefer Native loader, as it respects #coding directive + filename = loader.get_source(modname) + if filename: + return 'string', filename + except Exception as err: + pass # Try other "source-mining" method if loader and getattr(loader, 'get_filename', None): try: filename = loader.get_filename(modname) except Exception as err: raise PycodeError('error getting filename for %r' % filename, err) - if filename is None and loader: - try: - filename = loader.get_source(modname) - if filename: - return 'string', filename - except Exception as err: - raise PycodeError('error getting source for %r' % modname, err) if filename is None: raise PycodeError('no source found for module %r' % modname) filename = path.normpath(path.abspath(filename)) From da5cf1b66ecac2cd4b699196feea4119b40295ce Mon Sep 17 00:00:00 2001 From: hkm Date: Sat, 14 Dec 2019 22:08:44 +0300 Subject: [PATCH 02/22] maintainer suggested fixes --- sphinx/util/__init__.py | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/sphinx/util/__init__.py b/sphinx/util/__init__.py index 62f36cc0b..699763815 100644 --- a/sphinx/util/__init__.py +++ b/sphinx/util/__init__.py @@ -275,20 +275,25 @@ def get_module_source(modname: str) -> Tuple[str, str]: mod = import_module(modname) except Exception as err: raise PycodeError('error importing %r' % modname, err) - filename = getattr(mod, '__file__', None) loader = getattr(mod, '__loader__', None) - try: # prefer Native loader, as it respects #coding directive - filename = loader.get_source(modname) - if filename: - return 'string', filename - except Exception as err: - pass # Try other "source-mining" method - if loader and getattr(loader, 'get_filename', None): + if loader and getattr(loader, 'get_source', None): + # prefer Native loader, as it respects #coding directive + try: + filename = loader.get_source(modname) + if filename: + # no exception and not None - it must be module source + return 'string', filename + except ImportError as err: + pass # Try other "source-mining" methods + filename = getattr(mod, '__file__', None) + if filename is None and loader and getattr(loader, 'get_filename', None): + # have loader, but no filename try: filename = loader.get_filename(modname) - except Exception as err: - raise PycodeError('error getting filename for %r' % filename, err) + except ImportError as err: + raise PycodeError('error getting filename for %r' % modname, err) if filename is None: + # all methods for getting filename failed, so raise... raise PycodeError('no source found for module %r' % modname) filename = path.normpath(path.abspath(filename)) lfilename = filename.lower() From fa5cf6fcdc7b51693d5d15db792197401577c108 Mon Sep 17 00:00:00 2001 From: hkm Date: Sun, 15 Dec 2019 20:28:02 +0300 Subject: [PATCH 03/22] lost reference to source file name fixed. Test suit updated --- sphinx/pycode/__init__.py | 8 ++++---- sphinx/util/__init__.py | 20 ++++++++++---------- tests/test_util.py | 2 +- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/sphinx/pycode/__init__.py b/sphinx/pycode/__init__.py index 92153d1d0..2a3b7763c 100644 --- a/sphinx/pycode/__init__.py +++ b/sphinx/pycode/__init__.py @@ -63,10 +63,10 @@ class ModuleAnalyzer: return entry try: - type, source = get_module_source(modname) - if type == 'string': - obj = cls.for_string(source, modname) - else: + filename, source = get_module_source(modname) + if source is not None: + obj = cls.for_string(source, modname, filename if filename is not None else '') + elif filename is not None: obj = cls.for_file(source, modname) except PycodeError as err: cls.cache['module', modname] = err diff --git a/sphinx/util/__init__.py b/sphinx/util/__init__.py index 699763815..81bc51254 100644 --- a/sphinx/util/__init__.py +++ b/sphinx/util/__init__.py @@ -25,7 +25,7 @@ from hashlib import md5 from importlib import import_module from os import path from time import mktime, strptime -from typing import Any, Callable, Dict, IO, Iterable, Iterator, List, Pattern, Set, Tuple +from typing import Any, Callable, Dict, IO, Iterable, Iterator, List, Pattern, Set, Tuple, Optional from urllib.parse import urlsplit, urlunsplit, quote_plus, parse_qsl, urlencode from docutils.utils import relative_path @@ -265,27 +265,27 @@ def save_traceback(app: "Sphinx") -> str: return path -def get_module_source(modname: str) -> Tuple[str, str]: +def get_module_source(modname: str) -> Tuple[Optional[str], Optional[str]]: """Try to find the source code for a module. - Can return ('file', 'filename') in which case the source is in the given - file, or ('string', 'source') which which case the source is the string. + Returns ('filename', 'source'). One of it can be None if + no filename or source found """ try: mod = import_module(modname) except Exception as err: raise PycodeError('error importing %r' % modname, err) loader = getattr(mod, '__loader__', None) + filename = getattr(mod, '__file__', None) if loader and getattr(loader, 'get_source', None): # prefer Native loader, as it respects #coding directive try: - filename = loader.get_source(modname) - if filename: + source = loader.get_source(modname) + if source: # no exception and not None - it must be module source - return 'string', filename + return filename, source except ImportError as err: pass # Try other "source-mining" methods - filename = getattr(mod, '__file__', None) if filename is None and loader and getattr(loader, 'get_filename', None): # have loader, but no filename try: @@ -307,11 +307,11 @@ def get_module_source(modname: str) -> Tuple[str, str]: pat = '(?<=\\.egg)' + re.escape(os.path.sep) eggpath, _ = re.split(pat, filename, 1) if path.isfile(eggpath): - return 'file', filename + return filename, None if not path.isfile(filename): raise PycodeError('source file is not present: %r' % filename) - return 'file', filename + return filename, None def get_full_modname(modname: str, attribute: str) -> str: diff --git a/tests/test_util.py b/tests/test_util.py index 44a41dca1..4f9317df2 100644 --- a/tests/test_util.py +++ b/tests/test_util.py @@ -62,7 +62,7 @@ def test_display_chunk(): def test_get_module_source(): - assert get_module_source('sphinx') == ('file', sphinx.__file__) + assert get_module_source('sphinx') == (sphinx.__file__, sphinx.__loader__.get_source('sphinx')) # failed to obtain source information from builtin modules with pytest.raises(PycodeError): From 264329079b6b65da90adfec15baff841a01727cf Mon Sep 17 00:00:00 2001 From: hkm Date: Sun, 15 Dec 2019 20:50:27 +0300 Subject: [PATCH 04/22] Test suite updated - encoding not detected when getting sources from native loader --- tests/test_pycode.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_pycode.py b/tests/test_pycode.py index 5eccad0db..abe8ab58b 100644 --- a/tests/test_pycode.py +++ b/tests/test_pycode.py @@ -36,7 +36,8 @@ def test_ModuleAnalyzer_for_module(): assert analyzer.modname == 'sphinx' assert analyzer.srcname in (SPHINX_MODULE_PATH, os.path.abspath(SPHINX_MODULE_PATH)) - assert analyzer.encoding == 'utf-8' + # source should be loaded via native loader, so don`t know file enconding + assert analyzer.encoding == None def test_ModuleAnalyzer_for_file_in_egg(rootdir): From 1ca9dacbfe529282ac286a3a61542167e5d6bc65 Mon Sep 17 00:00:00 2001 From: hkm Date: Sun, 15 Dec 2019 21:47:57 +0300 Subject: [PATCH 05/22] Added test case for non ASCII & non UTF8 encoding Windows-1251 in test_pycode section --- sphinx/pycode/__init__.py | 2 +- tests/roots/test-pycode/cp_1251_coded.py | 4 ++++ tests/test_pycode.py | 8 +++++++- 3 files changed, 12 insertions(+), 2 deletions(-) create mode 100644 tests/roots/test-pycode/cp_1251_coded.py diff --git a/sphinx/pycode/__init__.py b/sphinx/pycode/__init__.py index 2a3b7763c..483eed432 100644 --- a/sphinx/pycode/__init__.py +++ b/sphinx/pycode/__init__.py @@ -67,7 +67,7 @@ class ModuleAnalyzer: if source is not None: obj = cls.for_string(source, modname, filename if filename is not None else '') elif filename is not None: - obj = cls.for_file(source, modname) + obj = cls.for_file(filename, modname) except PycodeError as err: cls.cache['module', modname] = err raise diff --git a/tests/roots/test-pycode/cp_1251_coded.py b/tests/roots/test-pycode/cp_1251_coded.py new file mode 100644 index 000000000..43d98f354 --- /dev/null +++ b/tests/roots/test-pycode/cp_1251_coded.py @@ -0,0 +1,4 @@ +#!python +# -*- coding: windows-1251 -*- + +X="" #:It MUST look like X="" \ No newline at end of file diff --git a/tests/test_pycode.py b/tests/test_pycode.py index abe8ab58b..cdae7d6be 100644 --- a/tests/test_pycode.py +++ b/tests/test_pycode.py @@ -31,13 +31,19 @@ def test_ModuleAnalyzer_for_file(): assert analyzer.encoding is None -def test_ModuleAnalyzer_for_module(): +def test_ModuleAnalyzer_for_module(rootdir): analyzer = ModuleAnalyzer.for_module('sphinx') assert analyzer.modname == 'sphinx' assert analyzer.srcname in (SPHINX_MODULE_PATH, os.path.abspath(SPHINX_MODULE_PATH)) # source should be loaded via native loader, so don`t know file enconding assert analyzer.encoding == None + path = rootdir / 'test-pycode' + sys.path.insert(0, path) + analyzer = ModuleAnalyzer.for_module('cp_1251_coded') + docs = analyzer.find_attr_docs() + sys.path.pop(0) + assert docs == {('', 'X'): ['It MUST look like X="\u0425"', '']} def test_ModuleAnalyzer_for_file_in_egg(rootdir): From c4e60b5b9ce786f941dd29d7636b39dd6c0d0630 Mon Sep 17 00:00:00 2001 From: kpnr Date: Mon, 16 Dec 2019 21:17:16 +0300 Subject: [PATCH 06/22] restore sys.path with statement --- tests/test_pycode.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/tests/test_pycode.py b/tests/test_pycode.py index cdae7d6be..cd039070c 100644 --- a/tests/test_pycode.py +++ b/tests/test_pycode.py @@ -40,10 +40,13 @@ def test_ModuleAnalyzer_for_module(rootdir): assert analyzer.encoding == None path = rootdir / 'test-pycode' sys.path.insert(0, path) - analyzer = ModuleAnalyzer.for_module('cp_1251_coded') - docs = analyzer.find_attr_docs() - sys.path.pop(0) - assert docs == {('', 'X'): ['It MUST look like X="\u0425"', '']} + try: + analyzer = ModuleAnalyzer.for_module('cp_1251_coded') + docs = analyzer.find_attr_docs() + assert docs == {('', 'X'): ['It MUST look like X="\u0425"', '']} + finally: + sys.path.pop(0) + def test_ModuleAnalyzer_for_file_in_egg(rootdir): From 83bf8451da70c1d1987ef9d864ee028364a25311 Mon Sep 17 00:00:00 2001 From: Takeshi KOMIYA Date: Wed, 25 Dec 2019 22:17:50 +0900 Subject: [PATCH 07/22] Migrate to py3 style type annotation: sphinx.domains.cpp --- sphinx/domains/cpp.py | 1555 +++++++++++++++-------------------------- 1 file changed, 579 insertions(+), 976 deletions(-) diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 4928fb997..b7f74266c 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -11,14 +11,21 @@ import re import warnings from copy import deepcopy +from typing import Any, Callable, Dict, Iterator, List, Match, Pattern, Tuple, Type, Union from docutils import nodes, utils +from docutils.nodes import Element, Node, TextElement from docutils.parsers.rst import directives from sphinx import addnodes +from sphinx.addnodes import desc_signature, pending_xref +from sphinx.application import Sphinx +from sphinx.builders import Builder +from sphinx.config import Config from sphinx.deprecation import RemovedInSphinx40Warning from sphinx.directives import ObjectDescription from sphinx.domains import Domain, ObjType +from sphinx.environment import BuildEnvironment from sphinx.errors import NoUri from sphinx.locale import _, __ from sphinx.roles import XRefRole @@ -30,16 +37,8 @@ from sphinx.util.docutils import SphinxDirective from sphinx.util.nodes import make_refnode -if False: - # For type annotation - from docutils.nodes import TextElement - from typing import Any, Callable, Dict, Iterator, List, Match, Pattern, Tuple, Type, Union # NOQA - from sphinx.application import Sphinx # NOQA - from sphinx.builders import Builder # NOQA - from sphinx.config import Config # NOQA - from sphinx.environment import BuildEnvironment # NOQA - logger = logging.getLogger(__name__) +StringifyTransform = Callable[[Any], str] """ Important note on ids @@ -580,8 +579,7 @@ _id_explicit_cast = { class NoOldIdError(Exception): # Used to avoid implementing unneeded id generation for old id schemes. @property - def description(self): - # type: () -> str + def description(self) -> str: warnings.warn('%s.description is deprecated. ' 'Coerce the instance to a string instead.' % self.__class__.__name__, RemovedInSphinx40Warning, stacklevel=2) @@ -590,8 +588,7 @@ class NoOldIdError(Exception): class DefinitionError(Exception): @property - def description(self): - # type: () -> str + def description(self) -> str: warnings.warn('%s.description is deprecated. ' 'Coerce the instance to a string instead.' % self.__class__.__name__, RemovedInSphinx40Warning, stacklevel=2) @@ -599,21 +596,18 @@ class DefinitionError(Exception): class _DuplicateSymbolError(Exception): - def __init__(self, symbol, declaration): - # type: (Symbol, Any) -> None + def __init__(self, symbol: "Symbol", declaration: Any) -> None: assert symbol assert declaration self.symbol = symbol self.declaration = declaration - def __str__(self): - # type: () -> str + def __str__(self) -> str: return "Internal C++ duplicate symbol error:\n%s" % self.symbol.dump(0) class ASTBase: - def __eq__(self, other): - # type: (Any) -> bool + def __eq__(self, other: Any) -> bool: if type(self) is not type(other): return False try: @@ -626,30 +620,24 @@ class ASTBase: __hash__ = None # type: Callable[[], int] - def clone(self): - # type: () -> Any + def clone(self) -> Any: """Clone a definition expression node.""" return deepcopy(self) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: raise NotImplementedError(repr(self)) - def __str__(self): - # type: () -> str + def __str__(self) -> str: return self._stringify(lambda ast: str(ast)) - def get_display_string(self): - # type: () -> str + def get_display_string(self) -> str: return self._stringify(lambda ast: ast.get_display_string()) - def __repr__(self): - # type: () -> str + def __repr__(self) -> str: return '<%s>' % self.__class__.__name__ -def _verify_description_mode(mode): - # type: (str) -> None +def _verify_description_mode(mode: str) -> None: if mode not in ('lastIsName', 'noneIsName', 'markType', 'markName', 'param'): raise Exception("Description mode '%s' is invalid." % mode) @@ -659,27 +647,23 @@ def _verify_description_mode(mode): ################################################################################ class ASTCPPAttribute(ASTBase): - def __init__(self, arg): - # type: (str) -> None + def __init__(self, arg: str) -> None: self.arg = arg def _stringify(self, transform): return "[[" + self.arg + "]]" - def describe_signature(self, signode): - # type: (addnodes.desc_signature) -> None + def describe_signature(self, signode: desc_signature) -> None: txt = str(self) signode.append(nodes.Text(txt, txt)) class ASTGnuAttribute(ASTBase): - def __init__(self, name, args): - # type: (str, Any) -> None + def __init__(self, name: str, args: Any) -> None: self.name = name self.args = args - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [self.name] if self.args: res.append('(') @@ -689,12 +673,10 @@ class ASTGnuAttribute(ASTBase): class ASTGnuAttributeList(ASTBase): - def __init__(self, attrs): - # type: (List[Any]) -> None + def __init__(self, attrs: List[Any]) -> None: self.attrs = attrs - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ['__attribute__(('] first = True for attr in self.attrs: @@ -705,8 +687,7 @@ class ASTGnuAttributeList(ASTBase): res.append('))') return ''.join(res) - def describe_signature(self, signode): - # type: (addnodes.desc_signature) -> None + def describe_signature(self, signode: desc_signature) -> None: txt = str(self) signode.append(nodes.Text(txt, txt)) @@ -714,33 +695,27 @@ class ASTGnuAttributeList(ASTBase): class ASTIdAttribute(ASTBase): """For simple attributes defined by the user.""" - def __init__(self, id): - # type: (str) -> None + def __init__(self, id: str) -> None: self.id = id - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return self.id - def describe_signature(self, signode): - # type: (addnodes.desc_signature) -> None + def describe_signature(self, signode: desc_signature) -> None: signode.append(nodes.Text(self.id, self.id)) class ASTParenAttribute(ASTBase): """For paren attributes defined by the user.""" - def __init__(self, id, arg): - # type: (str, str) -> None + def __init__(self, id: str, arg: str) -> None: self.id = id self.arg = arg - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return self.id + '(' + self.arg + ')' - def describe_signature(self, signode): - # type: (addnodes.desc_signature) -> None + def describe_signature(self, signode: desc_signature) -> None: txt = str(self) signode.append(nodes.Text(txt, txt)) @@ -750,12 +725,10 @@ class ASTParenAttribute(ASTBase): ################################################################################ class ASTPointerLiteral(ASTBase): - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return 'nullptr' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'LDnE' def describe_signature(self, signode, mode, env, symbol): @@ -766,15 +739,13 @@ class ASTBooleanLiteral(ASTBase): def __init__(self, value): self.value = value - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: if self.value: return 'true' else: return 'false' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if self.value: return 'L1E' else: @@ -785,16 +756,13 @@ class ASTBooleanLiteral(ASTBase): class ASTNumberLiteral(ASTBase): - def __init__(self, data): - # type: (str) -> None + def __init__(self, data: str) -> None: self.data = data - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return self.data - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return "L%sE" % self.data def describe_signature(self, signode, mode, env, symbol): @@ -804,8 +772,7 @@ class ASTNumberLiteral(ASTBase): class UnsupportedMultiCharacterCharLiteral(Exception): @property - def decoded(self): - # type: () -> str + def decoded(self) -> str: warnings.warn('%s.decoded is deprecated. ' 'Coerce the instance to a string instead.' % self.__class__.__name__, RemovedInSphinx40Warning, stacklevel=2) @@ -813,8 +780,7 @@ class UnsupportedMultiCharacterCharLiteral(Exception): class ASTCharLiteral(ASTBase): - def __init__(self, prefix, data): - # type: (str, str) -> None + def __init__(self, prefix: str, data: str) -> None: self.prefix = prefix # may be None when no prefix self.data = data assert prefix in _id_char_from_prefix @@ -825,15 +791,13 @@ class ASTCharLiteral(ASTBase): else: raise UnsupportedMultiCharacterCharLiteral(decoded) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: if self.prefix is None: return "'" + self.data + "'" else: return self.prefix + "'" + self.data + "'" - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return self.type + str(self.value) def describe_signature(self, signode, mode, env, symbol): @@ -842,16 +806,13 @@ class ASTCharLiteral(ASTBase): class ASTStringLiteral(ASTBase): - def __init__(self, data): - # type: (str) -> None + def __init__(self, data: str) -> None: self.data = data - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return self.data - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: # note: the length is not really correct with escaping return "LA%d_KcE" % (len(self.data) - 2) @@ -861,12 +822,10 @@ class ASTStringLiteral(ASTBase): class ASTThisLiteral(ASTBase): - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return "this" - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return "fpT" def describe_signature(self, signode, mode, env, symbol): @@ -877,12 +836,10 @@ class ASTParenExpr(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return '(' + transform(self.expr) + ')' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return self.expr.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -892,15 +849,13 @@ class ASTParenExpr(ASTBase): class ASTFoldExpr(ASTBase): - def __init__(self, leftExpr, op, rightExpr): - # type: (Any, str, Any) -> None + def __init__(self, leftExpr: Any, op: str, rightExpr: Any) -> None: assert leftExpr is not None or rightExpr is not None self.leftExpr = leftExpr self.op = op self.rightExpr = rightExpr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ['('] if self.leftExpr: res.append(transform(self.leftExpr)) @@ -916,8 +871,7 @@ class ASTFoldExpr(ASTBase): res.append(')') return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: assert version >= 3 if version == 3: return str(self) @@ -961,8 +915,7 @@ class ASTBinOpExpr(ASTBase): self.exprs = exprs self.ops = ops - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.exprs[0])) for i in range(1, len(self.exprs)): @@ -972,8 +925,7 @@ class ASTBinOpExpr(ASTBase): res.append(transform(self.exprs[i])) return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: assert version >= 2 res = [] for i in range(len(self.ops)): @@ -998,8 +950,7 @@ class ASTAssignmentExpr(ASTBase): self.exprs = exprs self.ops = ops - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.exprs[0])) for i in range(1, len(self.exprs)): @@ -1009,8 +960,7 @@ class ASTAssignmentExpr(ASTBase): res.append(transform(self.exprs[i])) return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: res = [] for i in range(len(self.ops)): res.append(_id_operator_v2[self.ops[i]]) @@ -1032,16 +982,14 @@ class ASTCastExpr(ASTBase): self.typ = typ self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ['('] res.append(transform(self.typ)) res.append(')') res.append(transform(self.expr)) return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'cv' + self.typ.get_id(version) + self.expr.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1056,12 +1004,10 @@ class ASTUnaryOpExpr(ASTBase): self.op = op self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.op) + transform(self.expr) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return _id_operator_unary_v2[self.op] + self.expr.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1073,12 +1019,10 @@ class ASTSizeofParamPack(ASTBase): def __init__(self, identifier): self.identifier = identifier - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return "sizeof...(" + transform(self.identifier) + ")" - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'sZ' + self.identifier.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1092,12 +1036,10 @@ class ASTSizeofType(ASTBase): def __init__(self, typ): self.typ = typ - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return "sizeof(" + transform(self.typ) + ")" - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'st' + self.typ.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1110,12 +1052,10 @@ class ASTSizeofExpr(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return "sizeof " + transform(self.expr) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'sz' + self.expr.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1127,12 +1067,10 @@ class ASTAlignofExpr(ASTBase): def __init__(self, typ): self.typ = typ - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return "alignof(" + transform(self.typ) + ")" - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'at' + self.typ.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1145,12 +1083,10 @@ class ASTNoexceptExpr(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return "noexcept(" + transform(self.expr) + ")" - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return 'nx' + self.expr.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1160,15 +1096,13 @@ class ASTNoexceptExpr(ASTBase): class ASTNewExpr(ASTBase): - def __init__(self, rooted, isNewTypeId, typ, initList): - # type: (bool, bool, ASTType, Any) -> None + def __init__(self, rooted: bool, isNewTypeId: bool, typ: "ASTType", initList: Any) -> None: self.rooted = rooted self.isNewTypeId = isNewTypeId self.typ = typ self.initList = initList - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.rooted: res.append('::') @@ -1182,8 +1116,7 @@ class ASTNewExpr(ASTBase): res.append(transform(self.initList)) return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: # the array part will be in the type mangling, so na is not used res = ['nw'] # TODO: placement @@ -1214,8 +1147,7 @@ class ASTDeleteExpr(ASTBase): self.array = array self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.rooted: res.append('::') @@ -1225,8 +1157,7 @@ class ASTDeleteExpr(ASTBase): res.append(transform(self.expr)) return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if self.array: id = "da" else: @@ -1249,8 +1180,7 @@ class ASTExplicitCast(ASTBase): self.typ = typ self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [self.cast] res.append('<') res.append(transform(self.typ)) @@ -1259,8 +1189,7 @@ class ASTExplicitCast(ASTBase): res.append(')') return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return (_id_explicit_cast[self.cast] + self.typ.get_id(version) + self.expr.get_id(version)) @@ -1280,12 +1209,10 @@ class ASTTypeId(ASTBase): self.typeOrExpr = typeOrExpr self.isType = isType - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return 'typeid(' + transform(self.typeOrExpr) + ')' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: prefix = 'ti' if self.isType else 'te' return prefix + self.typeOrExpr.get_id(version) @@ -1297,16 +1224,13 @@ class ASTTypeId(ASTBase): class ASTPostfixCallExpr(ASTBase): - def __init__(self, lst): - # type: (Union[ASTParenExprList, ASTBracedInitList]) -> None + def __init__(self, lst: Union["ASTParenExprList", "ASTBracedInitList"]) -> None: self.lst = lst - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.lst) - def get_id(self, idPrefix, version): - # type: (str, int) -> str + def get_id(self, idPrefix: str, version: int) -> str: res = ['cl', idPrefix] for e in self.lst.exprs: res.append(e.get_id(version)) @@ -1321,12 +1245,10 @@ class ASTPostfixArray(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return '[' + transform(self.expr) + ']' - def get_id(self, idPrefix, version): - # type: (str, int) -> str + def get_id(self, idPrefix: str, version: int) -> str: return 'ix' + idPrefix + self.expr.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1336,12 +1258,10 @@ class ASTPostfixArray(ASTBase): class ASTPostfixInc(ASTBase): - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return '++' - def get_id(self, idPrefix, version): - # type: (str, int) -> str + def get_id(self, idPrefix: str, version: int) -> str: return 'pp' + idPrefix def describe_signature(self, signode, mode, env, symbol): @@ -1349,12 +1269,10 @@ class ASTPostfixInc(ASTBase): class ASTPostfixDec(ASTBase): - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return '--' - def get_id(self, idPrefix, version): - # type: (str, int) -> str + def get_id(self, idPrefix: str, version: int) -> str: return 'mm' + idPrefix def describe_signature(self, signode, mode, env, symbol): @@ -1365,12 +1283,10 @@ class ASTPostfixMember(ASTBase): def __init__(self, name): self.name = name - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return '.' + transform(self.name) - def get_id(self, idPrefix, version): - # type: (str, int) -> str + def get_id(self, idPrefix: str, version: int) -> str: return 'dt' + idPrefix + self.name.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1382,12 +1298,10 @@ class ASTPostfixMemberOfPointer(ASTBase): def __init__(self, name): self.name = name - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return '->' + transform(self.name) - def get_id(self, idPrefix, version): - # type: (str, int) -> str + def get_id(self, idPrefix: str, version: int) -> str: return 'pt' + idPrefix + self.name.get_id(version) def describe_signature(self, signode, mode, env, symbol): @@ -1401,15 +1315,13 @@ class ASTPostfixExpr(ASTBase): self.prefix = prefix self.postFixes = postFixes - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [transform(self.prefix)] for p in self.postFixes: res.append(transform(p)) return ''.join(res) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: id = self.prefix.get_id(version) for p in self.postFixes: id = p.get_id(id, version) @@ -1425,12 +1337,10 @@ class ASTPackExpansionExpr(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.expr) + '...' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: id = self.expr.get_id(version) return 'sp' + id @@ -1443,12 +1353,10 @@ class ASTFallbackExpr(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return self.expr - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return str(self.expr) def describe_signature(self, signode, mode, env, symbol): @@ -1460,17 +1368,15 @@ class ASTFallbackExpr(ASTBase): ################################################################################ class ASTIdentifier(ASTBase): - def __init__(self, identifier): - # type: (str) -> None + def __init__(self, identifier: str) -> None: assert identifier is not None assert len(identifier) != 0 self.identifier = identifier - def is_anon(self): + def is_anon(self) -> bool: return self.identifier[0] == '@' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if self.is_anon() and version < 3: raise NoOldIdError() if version == 1: @@ -1491,16 +1397,14 @@ class ASTIdentifier(ASTBase): # and this is where we finally make a difference between __str__ and the display string - def __str__(self): - # type: () -> str + def __str__(self) -> str: return self.identifier - def get_display_string(self): - # type: () -> str + def get_display_string(self) -> str: return "[anonymous]" if self.is_anon() else self.identifier - def describe_signature(self, signode, mode, env, prefix, templateArgs, symbol): - # type: (Any, str, BuildEnvironment, str, str, Symbol) -> None + def describe_signature(self, signode: Any, mode: str, env: "BuildEnvironment", + prefix: str, templateArgs: str, symbol: "Symbol") -> None: _verify_description_mode(mode) if mode == 'markType': targetText = prefix + self.identifier + templateArgs @@ -1530,8 +1434,8 @@ class ASTIdentifier(ASTBase): class ASTTemplateKeyParamPackIdDefault(ASTBase): - def __init__(self, key, identifier, parameterPack, default): - # type: (str, ASTIdentifier, bool, ASTType) -> None + def __init__(self, key: str, identifier: ASTIdentifier, + parameterPack: bool, default: "ASTType") -> None: assert key if parameterPack: assert default is None @@ -1540,12 +1444,10 @@ class ASTTemplateKeyParamPackIdDefault(ASTBase): self.parameterPack = parameterPack self.default = default - def get_identifier(self): - # type: () -> ASTIdentifier + def get_identifier(self) -> ASTIdentifier: return self.identifier - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: assert version >= 2 # this is not part of the normal name mangling in C++ res = [] @@ -1555,8 +1457,7 @@ class ASTTemplateKeyParamPackIdDefault(ASTBase): res.append('0') # we need to put something return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [self.key] if self.parameterPack: if self.identifier: @@ -1571,8 +1472,8 @@ class ASTTemplateKeyParamPackIdDefault(ASTBase): res.append(transform(self.default)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: signode += nodes.Text(self.key) if self.parameterPack: if self.identifier: @@ -1588,28 +1489,23 @@ class ASTTemplateKeyParamPackIdDefault(ASTBase): class ASTTemplateParamType(ASTBase): - def __init__(self, data): - # type: (ASTTemplateKeyParamPackIdDefault) -> None + def __init__(self, data: ASTTemplateKeyParamPackIdDefault) -> None: assert data self.data = data @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> "ASTNestedName": id = self.get_identifier() return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False) @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.data.parameterPack - def get_identifier(self): - # type: () -> ASTIdentifier + def get_identifier(self) -> ASTIdentifier: return self.data.get_identifier() - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, symbol: "Symbol" = None) -> str: # this is not part of the normal name mangling in C++ assert version >= 2 if symbol: @@ -1618,34 +1514,29 @@ class ASTTemplateParamType(ASTBase): else: return self.data.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.data) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: self.data.describe_signature(signode, mode, env, symbol) class ASTTemplateParamConstrainedTypeWithInit(ASTBase): - def __init__(self, type, init): - # type: (Any, Any) -> None + def __init__(self, type: Any, init: Any) -> None: assert type self.type = type self.init = init @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> "ASTNestedName": return self.type.name @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.type.isPack - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, symbol: "Symbol" = None) -> str: # this is not part of the normal name mangling in C++ assert version >= 2 if symbol: @@ -1654,16 +1545,15 @@ class ASTTemplateParamConstrainedTypeWithInit(ASTBase): else: return self.type.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = transform(self.type) if self.init: res += " = " res += transform(self.init) return res - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: self.type.describe_signature(signode, mode, env, symbol) if self.init: signode += nodes.Text(" = ") @@ -1671,30 +1561,25 @@ class ASTTemplateParamConstrainedTypeWithInit(ASTBase): class ASTTemplateParamTemplateType(ASTBase): - def __init__(self, nestedParams, data): - # type: (Any, ASTTemplateKeyParamPackIdDefault) -> None + def __init__(self, nestedParams: Any, data: ASTTemplateKeyParamPackIdDefault) -> None: assert nestedParams assert data self.nestedParams = nestedParams self.data = data @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> "ASTNestedName": id = self.get_identifier() return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False) @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.data.parameterPack - def get_identifier(self): - # type: () -> ASTIdentifier + def get_identifier(self) -> ASTIdentifier: return self.data.get_identifier() - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, symbol: "Symbol" = None) -> str: assert version >= 2 # this is not part of the normal name mangling in C++ if symbol: @@ -1703,36 +1588,31 @@ class ASTTemplateParamTemplateType(ASTBase): else: return self.nestedParams.get_id(version) + self.data.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.nestedParams) + transform(self.data) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: self.nestedParams.describe_signature(signode, 'noneIsName', env, symbol) signode += nodes.Text(' ') self.data.describe_signature(signode, mode, env, symbol) class ASTTemplateParamNonType(ASTBase): - def __init__(self, param): - # type: (Any) -> None + def __init__(self, param: Any) -> None: assert param self.param = param @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> "ASTNestedName": id = self.get_identifier() return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False) @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.param.isPack - def get_identifier(self): - # type: () -> ASTIdentifier + def get_identifier(self) -> ASTIdentifier: name = self.param.name if name: assert len(name.names) == 1 @@ -1742,8 +1622,7 @@ class ASTTemplateParamNonType(ASTBase): else: return None - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, symbol: "Symbol" = None) -> str: assert version >= 2 # this is not part of the normal name mangling in C++ if symbol: @@ -1752,24 +1631,21 @@ class ASTTemplateParamNonType(ASTBase): else: return '_' + self.param.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.param) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: self.param.describe_signature(signode, mode, env, symbol) class ASTTemplateParams(ASTBase): - def __init__(self, params): - # type: (Any) -> None + def __init__(self, params: Any) -> None: assert params is not None self.params = params self.isNested = False # whether it's a template template param - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: assert version >= 2 res = [] res.append("I") @@ -1778,16 +1654,16 @@ class ASTTemplateParams(ASTBase): res.append("E") return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append("template<") res.append(", ".join(transform(a) for a in self.params)) res.append("> ") return ''.join(res) - def describe_signature(self, parentNode, mode, env, symbol, lineSpec=None): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol, bool) -> None + def describe_signature(self, parentNode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol", lineSpec: bool = None + ) -> None: # 'lineSpec' is defaulted becuase of template template parameters def makeLine(parentNode=parentNode): signode = addnodes.desc_signature_line() @@ -1813,28 +1689,23 @@ class ASTTemplateParams(ASTBase): class ASTTemplateIntroductionParameter(ASTBase): - def __init__(self, identifier, parameterPack): - # type: (ASTIdentifier, bool) -> None + def __init__(self, identifier: ASTIdentifier, parameterPack: bool) -> None: self.identifier = identifier self.parameterPack = parameterPack @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> "ASTNestedName": id = self.get_identifier() return ASTNestedName([ASTNestedNameElement(id, None)], [False], rooted=False) @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.parameterPack - def get_identifier(self): - # type: () -> ASTIdentifier + def get_identifier(self) -> ASTIdentifier: return self.identifier - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, symbol: "Symbol" = None) -> str: assert version >= 2 # this is not part of the normal name mangling in C++ if symbol: @@ -1846,8 +1717,7 @@ class ASTTemplateIntroductionParameter(ASTBase): else: return '0' # we need to put something - def get_id_as_arg(self, version): - # type: (int) -> str + def get_id_as_arg(self, version: int) -> str: assert version >= 2 # used for the implicit requires clause res = self.identifier.get_id(version) @@ -1856,30 +1726,27 @@ class ASTTemplateIntroductionParameter(ASTBase): else: return res - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.parameterPack: res.append('...') res.append(transform(self.identifier)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: if self.parameterPack: signode += nodes.Text('...') self.identifier.describe_signature(signode, mode, env, '', '', symbol) class ASTTemplateIntroduction(ASTBase): - def __init__(self, concept, params): - # type: (Any, List[Any]) -> None + def __init__(self, concept: Any, params: List[Any]) -> None: assert len(params) > 0 self.concept = concept self.params = params - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: assert version >= 2 # first do the same as a normal template parameter list res = [] @@ -1897,8 +1764,7 @@ class ASTTemplateIntroduction(ASTBase): res.append("E") return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.concept)) res.append('{') @@ -1906,8 +1772,8 @@ class ASTTemplateIntroduction(ASTBase): res.append('} ') return ''.join(res) - def describe_signature(self, parentNode, mode, env, symbol, lineSpec): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol, bool) -> None + def describe_signature(self, parentNode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol", lineSpec: bool) -> None: # Note: 'lineSpec' has no effect on template introductions. signode = addnodes.desc_signature_line() parentNode += signode @@ -1924,13 +1790,11 @@ class ASTTemplateIntroduction(ASTBase): class ASTTemplateDeclarationPrefix(ASTBase): - def __init__(self, templates): - # type: (List[Any]) -> None + def __init__(self, templates: List[Any]) -> None: # templates is None means it's an explicit instantiation of a variable self.templates = templates - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: assert version >= 2 # this is not part of a normal name mangling system res = [] @@ -1938,15 +1802,14 @@ class ASTTemplateDeclarationPrefix(ASTBase): res.append(t.get_id(version)) return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] for t in self.templates: res.append(transform(t)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol, lineSpec): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol, bool) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol", lineSpec: bool) -> None: _verify_description_mode(mode) for t in self.templates: t.describe_signature(signode, 'lastIsName', env, symbol, lineSpec) @@ -1959,16 +1822,15 @@ class ASTOperator(ASTBase): def is_anon(self): return False - def is_operator(self): - # type: () -> bool + def is_operator(self) -> bool: return True - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: raise NotImplementedError() - def describe_signature(self, signode, mode, env, prefix, templateArgs, symbol): - # type: (addnodes.desc_signature, str, Any, str, str, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", prefix: str, templateArgs: str, + symbol: "Symbol") -> None: _verify_description_mode(mode) identifier = str(self) if mode == 'lastIsName': @@ -1978,12 +1840,10 @@ class ASTOperator(ASTBase): class ASTOperatorBuildIn(ASTOperator): - def __init__(self, op): - # type: (str) -> None + def __init__(self, op: str) -> None: self.op = op - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: ids = _id_operator_v1 else: @@ -1993,8 +1853,7 @@ class ASTOperatorBuildIn(ASTOperator): 'be mapped to an id.' % self.op) return ids[self.op] - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: if self.op in ('new', 'new[]', 'delete', 'delete[]'): return 'operator ' + self.op else: @@ -2002,40 +1861,33 @@ class ASTOperatorBuildIn(ASTOperator): class ASTOperatorType(ASTOperator): - def __init__(self, type): - # type: (Any) -> None + def __init__(self, type: Any) -> None: self.type = type - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: return 'castto-%s-operator' % self.type.get_id(version) else: return 'cv' + self.type.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return ''.join(['operator ', transform(self.type)]) - def get_name_no_template(self): - # type: () -> str + def get_name_no_template(self) -> str: return str(self) class ASTOperatorLiteral(ASTOperator): - def __init__(self, identifier): - # type: (Any) -> None + def __init__(self, identifier: Any) -> None: self.identifier = identifier - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: raise NoOldIdError() else: return 'li' + self.identifier.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return 'operator""' + transform(self.identifier) @@ -2043,36 +1895,31 @@ class ASTOperatorLiteral(ASTOperator): class ASTTemplateArgConstant(ASTBase): - def __init__(self, value): - # type: (Any) -> None + def __init__(self, value: Any) -> None: self.value = value - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.value) - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: return str(self).replace(' ', '-') if version == 2: return 'X' + str(self) + 'E' return 'X' + self.value.get_id(version) + 'E' - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.value.describe_signature(signode, mode, env, symbol) class ASTTemplateArgs(ASTBase): - def __init__(self, args): - # type: (List[Any]) -> None + def __init__(self, args: List[Any]) -> None: assert args is not None self.args = args - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: res = [] res.append(':') @@ -2087,13 +1934,12 @@ class ASTTemplateArgs(ASTBase): res.append('E') return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ', '.join(transform(a) for a in self.args) return '<' + res + '>' - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode += nodes.Text('<') first = True @@ -2106,31 +1952,28 @@ class ASTTemplateArgs(ASTBase): class ASTNestedNameElement(ASTBase): - def __init__(self, identOrOp, templateArgs): - # type: (Union[ASTIdentifier, ASTOperator], ASTTemplateArgs) -> None + def __init__(self, identOrOp: Union["ASTIdentifier", "ASTOperator"], + templateArgs: ASTTemplateArgs) -> None: self.identOrOp = identOrOp self.templateArgs = templateArgs - def is_operator(self): - # type: () -> bool + def is_operator(self) -> bool: return False - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: res = self.identOrOp.get_id(version) if self.templateArgs: res += self.templateArgs.get_id(version) return res - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = transform(self.identOrOp) if self.templateArgs: res += transform(self.templateArgs) return res - def describe_signature(self, signode, mode, env, prefix, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, str, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", prefix: str, symbol: "Symbol") -> None: tArgs = str(self.templateArgs) if self.templateArgs is not None else '' self.identOrOp.describe_signature(signode, mode, env, prefix, tArgs, symbol) if self.templateArgs is not None: @@ -2138,8 +1981,8 @@ class ASTNestedNameElement(ASTBase): class ASTNestedName(ASTBase): - def __init__(self, names, templates, rooted): - # type: (List[ASTNestedNameElement], List[bool], bool) -> None + def __init__(self, names: List[ASTNestedNameElement], + templates: List[bool], rooted: bool) -> None: assert len(names) > 0 self.names = names self.templates = templates @@ -2147,12 +1990,10 @@ class ASTNestedName(ASTBase): self.rooted = rooted @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> "ASTNestedName": return self - def num_templates(self): - # type: () -> int + def num_templates(self) -> int: count = 0 for n in self.names: if n.is_operator(): @@ -2161,8 +2002,7 @@ class ASTNestedName(ASTBase): count += 1 return count - def get_id(self, version, modifiers=''): - # type: (int, str) -> str + def get_id(self, version: int, modifiers: str = '') -> str: if version == 1: tt = str(self) if tt in _id_shorthands_v1: @@ -2180,8 +2020,7 @@ class ASTNestedName(ASTBase): res.append('E') return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.rooted: res.append('') @@ -2194,8 +2033,8 @@ class ASTNestedName(ASTBase): res.append(transform(n)) return '::'.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) # just print the name part, with template args, not template params if mode == 'noneIsName': @@ -2254,16 +2093,13 @@ class ASTNestedName(ASTBase): class ASTTrailingTypeSpecFundamental(ASTBase): - def __init__(self, name): - # type: (str) -> None + def __init__(self, name: str) -> None: self.name = name - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return self.name - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: res = [] for a in self.name.split(' '): @@ -2280,28 +2116,24 @@ class ASTTrailingTypeSpecFundamental(ASTBase): 'parser should have rejected it.' % self.name) return _id_fundamental_v2[self.name] - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: signode += nodes.Text(str(self.name)) class ASTTrailingTypeSpecName(ASTBase): - def __init__(self, prefix, nestedName): - # type: (str, Any) -> None + def __init__(self, prefix: str, nestedName: Any) -> None: self.prefix = prefix self.nestedName = nestedName @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.nestedName - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return self.nestedName.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.prefix: res.append(self.prefix) @@ -2309,8 +2141,8 @@ class ASTTrailingTypeSpecName(ASTBase): res.append(transform(self.nestedName)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: if self.prefix: signode += addnodes.desc_annotation(self.prefix, self.prefix) signode += nodes.Text(' ') @@ -2318,18 +2150,16 @@ class ASTTrailingTypeSpecName(ASTBase): class ASTTrailingTypeSpecDecltypeAuto(ASTBase): - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return 'decltype(auto)' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: raise NoOldIdError() return 'Dc' - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: signode.append(nodes.Text(str(self))) @@ -2337,31 +2167,27 @@ class ASTTrailingTypeSpecDecltype(ASTBase): def __init__(self, expr): self.expr = expr - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return 'decltype(' + transform(self.expr) + ')' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: raise NoOldIdError() return 'DT' + self.expr.get_id(version) + "E" - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: signode.append(nodes.Text('decltype(')) self.expr.describe_signature(signode, mode, env, symbol) signode.append(nodes.Text(')')) class ASTFunctionParameter(ASTBase): - def __init__(self, arg, ellipsis=False): - # type: (Any, bool) -> None + def __init__(self, arg: Any, ellipsis: bool = False) -> None: self.arg = arg self.ellipsis = ellipsis - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, symbol: "Symbol" = None) -> str: # this is not part of the normal name mangling in C++ if symbol: # the anchor will be our parent @@ -2372,15 +2198,14 @@ class ASTFunctionParameter(ASTBase): else: return self.arg.get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: if self.ellipsis: return '...' else: return transform(self.arg) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) if self.ellipsis: signode += nodes.Text('...') @@ -2389,9 +2214,8 @@ class ASTFunctionParameter(ASTBase): class ASTParametersQualifiers(ASTBase): - def __init__(self, args, volatile, const, refQual, exceptionSpec, override, - final, initializer): - # type: (List[Any], bool, bool, str, str, bool, bool, str) -> None + def __init__(self, args: List[Any], volatile: bool, const: bool, refQual: str, + exceptionSpec: str, override: bool, final: bool, initializer: str) -> None: self.args = args self.volatile = volatile self.const = const @@ -2402,12 +2226,10 @@ class ASTParametersQualifiers(ASTBase): self.initializer = initializer @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.args - def get_modifiers_id(self, version): - # type: (int) -> str + def get_modifiers_id(self, version: int) -> str: res = [] if self.volatile: res.append('V') @@ -2422,8 +2244,7 @@ class ASTParametersQualifiers(ASTBase): res.append('R') return ''.join(res) - def get_param_id(self, version): - # type: (int) -> str + def get_param_id(self, version: int) -> str: if version == 1: if len(self.args) == 0: return '' @@ -2434,8 +2255,7 @@ class ASTParametersQualifiers(ASTBase): else: return ''.join(a.get_id(version) for a in self.args) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append('(') first = True @@ -2464,8 +2284,8 @@ class ASTParametersQualifiers(ASTBase): res.append(self.initializer) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) paramlist = addnodes.desc_parameterlist() for arg in self.args: @@ -2501,9 +2321,9 @@ class ASTParametersQualifiers(ASTBase): class ASTDeclSpecsSimple(ASTBase): - def __init__(self, storage, threadLocal, inline, virtual, explicit, - constexpr, volatile, const, friend, attrs): - # type: (str, bool, bool, bool, bool, bool, bool, bool, bool, List[Any]) -> None + def __init__(self, storage: str, threadLocal: bool, inline: bool, virtual: bool, + explicit: bool, constexpr: bool, volatile: bool, const: bool, + friend: bool, attrs: List[Any]) -> None: self.storage = storage self.threadLocal = threadLocal self.inline = inline @@ -2515,8 +2335,7 @@ class ASTDeclSpecsSimple(ASTBase): self.friend = friend self.attrs = attrs - def mergeWith(self, other): - # type: (ASTDeclSpecsSimple) -> ASTDeclSpecsSimple + def mergeWith(self, other: "ASTDeclSpecsSimple") -> "ASTDeclSpecsSimple": if not other: return self return ASTDeclSpecsSimple(self.storage or other.storage, @@ -2530,8 +2349,7 @@ class ASTDeclSpecsSimple(ASTBase): self.friend or other.friend, self.attrs + other.attrs) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] # type: List[str] res.extend(transform(attr) for attr in self.attrs) if self.storage: @@ -2554,8 +2372,7 @@ class ASTDeclSpecsSimple(ASTBase): res.append('const') return ' '.join(res) - def describe_signature(self, modifiers): - # type: (List[nodes.Node]) -> None + def describe_signature(self, modifiers: List[Node]) -> None: def _add(modifiers, text): if len(modifiers) > 0: modifiers.append(nodes.Text(' ')) @@ -2585,8 +2402,8 @@ class ASTDeclSpecsSimple(ASTBase): class ASTDeclSpecs(ASTBase): - def __init__(self, outer, leftSpecs, rightSpecs, trailing): - # type: (Any, ASTDeclSpecsSimple, ASTDeclSpecsSimple, Any) -> None + def __init__(self, outer: Any, leftSpecs: ASTDeclSpecsSimple, + rightSpecs: ASTDeclSpecsSimple, trailing: Any) -> None: # leftSpecs and rightSpecs are used for output # allSpecs are used for id generation self.outer = outer @@ -2596,12 +2413,10 @@ class ASTDeclSpecs(ASTBase): self.trailingTypeSpec = trailing @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.trailingTypeSpec.name - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: res = [] res.append(self.trailingTypeSpec.get_id(version)) @@ -2619,8 +2434,7 @@ class ASTDeclSpecs(ASTBase): res.append(self.trailingTypeSpec.get_id(version)) return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] # type: List[str] l = transform(self.leftSpecs) if len(l) > 0: @@ -2636,8 +2450,8 @@ class ASTDeclSpecs(ASTBase): res.append(r) return "".join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) modifiers = [] # type: List[nodes.Node] @@ -2667,15 +2481,13 @@ class ASTArray(ASTBase): def __init__(self, size): self.size = size - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: if self.size: return '[' + transform(self.size) + ']' else: return '[]' - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: if version == 1: return 'A' if version == 2: @@ -2697,8 +2509,7 @@ class ASTArray(ASTBase): class ASTDeclaratorPtr(ASTBase): - def __init__(self, next, volatile, const, attrs): - # type: (Any, bool, bool, Any) -> None + def __init__(self, next: Any, volatile: bool, const: bool, attrs: Any) -> None: assert next self.next = next self.volatile = volatile @@ -2706,22 +2517,18 @@ class ASTDeclaratorPtr(ASTBase): self.attrs = attrs @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.next.name @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.next.function_params - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: # TODO: if has paramPack, then False ? return True - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ['*'] for a in self.attrs: res.append(transform(a)) @@ -2739,16 +2546,13 @@ class ASTDeclaratorPtr(ASTBase): res.append(transform(self.next)) return ''.join(res) - def get_modifiers_id(self, version): - # type: (int) -> str + def get_modifiers_id(self, version: int) -> str: return self.next.get_modifiers_id(version) - def get_param_id(self, version): - # type: (int) -> str + def get_param_id(self, version: int) -> str: return self.next.get_param_id(version) - def get_ptr_suffix_id(self, version): - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: if version == 1: res = ['P'] if self.volatile: @@ -2766,8 +2570,7 @@ class ASTDeclaratorPtr(ASTBase): res.append('C') return ''.join(res) - def get_type_id(self, version, returnTypeId): - # type: (int, str) -> str + def get_type_id(self, version: int, returnTypeId: str) -> str: # ReturnType *next, so we are part of the return type of 'next res = ['P'] if self.volatile: @@ -2777,12 +2580,11 @@ class ASTDeclaratorPtr(ASTBase): res.append(returnTypeId) return self.next.get_type_id(version, returnTypeId=''.join(res)) - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return self.next.is_function_type() - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode += nodes.Text("*") for a in self.attrs: @@ -2805,33 +2607,27 @@ class ASTDeclaratorPtr(ASTBase): class ASTDeclaratorRef(ASTBase): - def __init__(self, next, attrs): - # type: (Any, Any) -> None + def __init__(self, next: Any, attrs: Any) -> None: assert next self.next = next self.attrs = attrs @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.next.name @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return True @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.next.function_params - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: return self.next.require_space_after_declSpecs() - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ['&'] for a in self.attrs: res.append(transform(a)) @@ -2840,33 +2636,28 @@ class ASTDeclaratorRef(ASTBase): res.append(transform(self.next)) return ''.join(res) - def get_modifiers_id(self, version): - # type: (int) -> str + def get_modifiers_id(self, version: int) -> str: return self.next.get_modifiers_id(version) - def get_param_id(self, version): # only the parameters (if any) - # type: (int) -> str + def get_param_id(self, version: int) -> str: # only the parameters (if any) return self.next.get_param_id(version) - def get_ptr_suffix_id(self, version): - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: if version == 1: return 'R' + self.next.get_ptr_suffix_id(version) else: return self.next.get_ptr_suffix_id(version) + 'R' - def get_type_id(self, version, returnTypeId): - # type: (int, str) -> str + def get_type_id(self, version: int, returnTypeId: str) -> str: assert version >= 2 # ReturnType &next, so we are part of the return type of 'next return self.next.get_type_id(version, returnTypeId='R' + returnTypeId) - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return self.next.is_function_type() - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode += nodes.Text("&") for a in self.attrs: @@ -2877,59 +2668,49 @@ class ASTDeclaratorRef(ASTBase): class ASTDeclaratorParamPack(ASTBase): - def __init__(self, next): - # type: (Any) -> None + def __init__(self, next: Any) -> None: assert next self.next = next @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.next.name @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.next.function_params - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: return False - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = transform(self.next) if self.next.name: res = ' ' + res return '...' + res - def get_modifiers_id(self, version): - # type: (int) -> str + def get_modifiers_id(self, version: int) -> str: return self.next.get_modifiers_id(version) - def get_param_id(self, version): # only the parameters (if any) - # type: (int) -> str + def get_param_id(self, version: int) -> str: # only the parameters (if any) return self.next.get_param_id(version) - def get_ptr_suffix_id(self, version): - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: if version == 1: return 'Dp' + self.next.get_ptr_suffix_id(version) else: return self.next.get_ptr_suffix_id(version) + 'Dp' - def get_type_id(self, version, returnTypeId): - # type: (int, str) -> str + def get_type_id(self, version: int, returnTypeId: str) -> str: assert version >= 2 # ReturnType... next, so we are part of the return type of 'next return self.next.get_type_id(version, returnTypeId='Dp' + returnTypeId) - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return self.next.is_function_type() - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode += nodes.Text("...") if self.next.name: @@ -2938,8 +2719,7 @@ class ASTDeclaratorParamPack(ASTBase): class ASTDeclaratorMemPtr(ASTBase): - def __init__(self, className, const, volatile, next): - # type: (Any, bool, bool, Any) -> None + def __init__(self, className: Any, const: bool, volatile: bool, next: Any) -> None: assert className assert next self.className = className @@ -2948,21 +2728,17 @@ class ASTDeclaratorMemPtr(ASTBase): self.next = next @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.next.name @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.next.function_params - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: return True - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.className)) res.append('::*') @@ -2975,30 +2751,26 @@ class ASTDeclaratorMemPtr(ASTBase): res.append(transform(self.next)) return ''.join(res) - def get_modifiers_id(self, version): - # type: (int) -> str + def get_modifiers_id(self, version: int) -> str: if version == 1: raise NoOldIdError() else: return self.next.get_modifiers_id(version) - def get_param_id(self, version): # only the parameters (if any) - # type: (int) -> str + def get_param_id(self, version: int) -> str: # only the parameters (if any) if version == 1: raise NoOldIdError() else: return self.next.get_param_id(version) - def get_ptr_suffix_id(self, version): - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: if version == 1: raise NoOldIdError() else: raise NotImplementedError() return self.next.get_ptr_suffix_id(version) + 'Dp' - def get_type_id(self, version, returnTypeId): - # type: (int, str) -> str + def get_type_id(self, version: int, returnTypeId: str) -> str: assert version >= 2 # ReturnType name::* next, so we are part of the return type of next nextReturnTypeId = '' @@ -3011,12 +2783,11 @@ class ASTDeclaratorMemPtr(ASTBase): nextReturnTypeId += returnTypeId return self.next.get_type_id(version, nextReturnTypeId) - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return self.next.is_function_type() - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.className.describe_signature(signode, mode, env, symbol) signode += nodes.Text('::*') @@ -3036,8 +2807,7 @@ class ASTDeclaratorMemPtr(ASTBase): class ASTDeclaratorParen(ASTBase): - def __init__(self, inner, next): - # type: (Any, Any) -> None + def __init__(self, inner: Any, next: Any) -> None: assert inner assert next self.inner = inner @@ -3045,37 +2815,30 @@ class ASTDeclaratorParen(ASTBase): # TODO: we assume the name, params, and qualifiers are in inner @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.inner.name @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.inner.function_params - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: return True - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = ['('] res.append(transform(self.inner)) res.append(')') res.append(transform(self.next)) return ''.join(res) - def get_modifiers_id(self, version): - # type: (int) -> str + def get_modifiers_id(self, version: int) -> str: return self.inner.get_modifiers_id(version) - def get_param_id(self, version): # only the parameters (if any) - # type: (int) -> str + def get_param_id(self, version: int) -> str: # only the parameters (if any) return self.inner.get_param_id(version) - def get_ptr_suffix_id(self, version): - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: if version == 1: raise NoOldIdError() # TODO: was this implemented before? return self.next.get_ptr_suffix_id(version) + \ @@ -3084,19 +2847,17 @@ class ASTDeclaratorParen(ASTBase): return self.inner.get_ptr_suffix_id(version) + \ self.next.get_ptr_suffix_id(version) - def get_type_id(self, version, returnTypeId): - # type: (int, str) -> str + def get_type_id(self, version: int, returnTypeId: str) -> str: assert version >= 2 # ReturnType (inner)next, so 'inner' returns everything outside nextId = self.next.get_type_id(version, returnTypeId) return self.inner.get_type_id(version, returnTypeId=nextId) - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return self.inner.is_function_type() - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode += nodes.Text('(') self.inner.describe_signature(signode, mode, env, symbol) @@ -3105,47 +2866,40 @@ class ASTDeclaratorParen(ASTBase): class ASTDeclaratorNameParamQual(ASTBase): - def __init__(self, declId, arrayOps, paramQual): - # type: (Any, List[Any], Any) -> None + def __init__(self, declId: Any, arrayOps: List[Any], paramQual: Any) -> None: self.declId = declId self.arrayOps = arrayOps self.paramQual = paramQual @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.declId @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return False @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.paramQual.function_params - def get_modifiers_id(self, version): # only the modifiers for a function, e.g., - # type: (int) -> str + # only the modifiers for a function, e.g., + def get_modifiers_id(self, version: int) -> str: # cv-qualifiers if self.paramQual: return self.paramQual.get_modifiers_id(version) raise Exception("This should only be called on a function: %s" % self) - def get_param_id(self, version): # only the parameters (if any) - # type: (int) -> str + def get_param_id(self, version: int) -> str: # only the parameters (if any) if self.paramQual: return self.paramQual.get_param_id(version) else: return '' - def get_ptr_suffix_id(self, version): # only the array specifiers - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: # only the array specifiers return ''.join(a.get_id(version) for a in self.arrayOps) - def get_type_id(self, version, returnTypeId): - # type: (int, str) -> str + def get_type_id(self, version: int, returnTypeId: str) -> str: assert version >= 2 res = [] # TOOD: can we actually have both array ops and paramQual? @@ -3162,16 +2916,13 @@ class ASTDeclaratorNameParamQual(ASTBase): # ------------------------------------------------------------------------ - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: return self.declId is not None - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return self.paramQual is not None - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.declId: res.append(transform(self.declId)) @@ -3181,8 +2932,8 @@ class ASTDeclaratorNameParamQual(ASTBase): res.append(transform(self.paramQual)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) if self.declId: self.declId.describe_signature(signode, mode, env, symbol) @@ -3198,30 +2949,24 @@ class ASTDeclaratorNameBitField(ASTBase): self.size = size @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.declId - def get_param_id(self, version): # only the parameters (if any) - # type: (int) -> str + def get_param_id(self, version: int) -> str: # only the parameters (if any) return '' - def get_ptr_suffix_id(self, version): # only the array specifiers - # type: (int) -> str + def get_ptr_suffix_id(self, version: int) -> str: # only the array specifiers return '' # ------------------------------------------------------------------------ - def require_space_after_declSpecs(self): - # type: () -> bool + def require_space_after_declSpecs(self) -> bool: return self.declId is not None - def is_function_type(self): - # type: () -> bool + def is_function_type(self) -> bool: return False - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.declId: res.append(transform(self.declId)) @@ -3229,8 +2974,8 @@ class ASTDeclaratorNameBitField(ASTBase): res.append(transform(self.size)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) if self.declId: self.declId.describe_signature(signode, mode, env, symbol) @@ -3239,21 +2984,18 @@ class ASTDeclaratorNameBitField(ASTBase): class ASTParenExprList(ASTBase): - def __init__(self, exprs): - # type: (List[Any]) -> None + def __init__(self, exprs: List[Any]) -> None: self.exprs = exprs - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return "pi%sE" % ''.join(e.get_id(version) for e in self.exprs) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: exprs = [transform(e) for e in self.exprs] return '(%s)' % ', '.join(exprs) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode.append(nodes.Text('(')) first = True @@ -3267,23 +3009,20 @@ class ASTParenExprList(ASTBase): class ASTBracedInitList(ASTBase): - def __init__(self, exprs, trailingComma): - # type: (List[Any], bool) -> None + def __init__(self, exprs: List[Any], trailingComma: bool) -> None: self.exprs = exprs self.trailingComma = trailingComma - def get_id(self, version): - # type: (int) -> str + def get_id(self, version: int) -> str: return "il%sE" % ''.join(e.get_id(version) for e in self.exprs) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: exprs = [transform(e) for e in self.exprs] trailingComma = ',' if self.trailingComma else '' return '{%s%s}' % (', '.join(exprs), trailingComma) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) signode.append(nodes.Text('{')) first = True @@ -3299,21 +3038,19 @@ class ASTBracedInitList(ASTBase): class ASTInitializer(ASTBase): - def __init__(self, value, hasAssign=True): - # type: (Any, bool) -> None + def __init__(self, value: Any, hasAssign: bool = True) -> None: self.value = value self.hasAssign = hasAssign - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: val = transform(self.value) if self.hasAssign: return ' = ' + val else: return val - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) if self.hasAssign: signode.append(nodes.Text(' = ')) @@ -3321,30 +3058,26 @@ class ASTInitializer(ASTBase): class ASTType(ASTBase): - def __init__(self, declSpecs, decl): - # type: (Any, Any) -> None + def __init__(self, declSpecs: Any, decl: Any) -> None: assert declSpecs assert decl self.declSpecs = declSpecs self.decl = decl @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.decl.name @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.decl.isPack @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: return self.decl.function_params - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, + symbol: "Symbol" = None) -> str: if version == 1: res = [] if objectType: # needs the name @@ -3396,8 +3129,7 @@ class ASTType(ASTBase): res.append(typeId) return ''.join(res) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] declSpecs = transform(self.declSpecs) res.append(declSpecs) @@ -3406,15 +3138,14 @@ class ASTType(ASTBase): res.append(transform(self.decl)) return ''.join(res) - def get_type_declaration_prefix(self): - # type: () -> str + def get_type_declaration_prefix(self) -> str: if self.declSpecs.trailingTypeSpec: return 'typedef' else: return 'type' - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.declSpecs.describe_signature(signode, 'markType', env, symbol) if (self.decl.require_space_after_declSpecs() and @@ -3428,23 +3159,20 @@ class ASTType(ASTBase): class ASTTypeWithInit(ASTBase): - def __init__(self, type, init): - # type: (Any, Any) -> None + def __init__(self, type: Any, init: Any) -> None: self.type = type self.init = init @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.type.name @property - def isPack(self): - # type: () -> bool + def isPack(self) -> bool: return self.type.isPack - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, + symbol: "Symbol" = None) -> str: if objectType != 'member': return self.type.get_id(version, objectType) if version == 1: @@ -3452,16 +3180,15 @@ class ASTTypeWithInit(ASTBase): self.type.get_id(version)) return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.type)) if self.init: res.append(transform(self.init)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.type.describe_signature(signode, mode, env, symbol) if self.init: @@ -3469,19 +3196,17 @@ class ASTTypeWithInit(ASTBase): class ASTTypeUsing(ASTBase): - def __init__(self, name, type): - # type: (Any, Any) -> None + def __init__(self, name: Any, type: Any) -> None: self.name = name self.type = type - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, + symbol: "Symbol" = None) -> str: if version == 1: raise NoOldIdError() return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.name)) if self.type: @@ -3489,12 +3214,11 @@ class ASTTypeUsing(ASTBase): res.append(transform(self.type)) return ''.join(res) - def get_type_declaration_prefix(self): - # type: () -> str + def get_type_declaration_prefix(self) -> str: return 'using' - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.name.describe_signature(signode, mode, env, symbol=symbol) if self.type: @@ -3503,46 +3227,42 @@ class ASTTypeUsing(ASTBase): class ASTConcept(ASTBase): - def __init__(self, nestedName, initializer): - # type: (Any, Any) -> None + def __init__(self, nestedName: Any, initializer: Any) -> None: self.nestedName = nestedName self.initializer = initializer @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.nestedName - def get_id(self, version, objectType=None, symbol=None): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str = None, + symbol: "Symbol" = None) -> str: if version == 1: raise NoOldIdError() return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = transform(self.nestedName) if self.initializer: res += transform(self.initializer) return res - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: self.nestedName.describe_signature(signode, mode, env, symbol) if self.initializer: self.initializer.describe_signature(signode, mode, env, symbol) class ASTBaseClass(ASTBase): - def __init__(self, name, visibility, virtual, pack): - # type: (ASTNestedName, str, bool, bool) -> None + def __init__(self, name: ASTNestedName, visibility: str, + virtual: bool, pack: bool) -> None: self.name = name self.visibility = visibility self.virtual = virtual self.pack = pack - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.visibility is not None: @@ -3555,8 +3275,8 @@ class ASTBaseClass(ASTBase): res.append('...') return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) if self.visibility is not None: signode += addnodes.desc_annotation(self.visibility, @@ -3571,18 +3291,15 @@ class ASTBaseClass(ASTBase): class ASTClass(ASTBase): - def __init__(self, name, final, bases): - # type: (ASTNestedName, bool, List[ASTBaseClass]) -> None + def __init__(self, name: ASTNestedName, final: bool, bases: List[ASTBaseClass]) -> None: self.name = name self.final = final self.bases = bases - def get_id(self, version, objectType, symbol): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str, symbol: "Symbol") -> str: return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.name)) if self.final: @@ -3597,8 +3314,8 @@ class ASTClass(ASTBase): res.append(transform(b)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.name.describe_signature(signode, mode, env, symbol=symbol) if self.final: @@ -3613,41 +3330,35 @@ class ASTClass(ASTBase): class ASTUnion(ASTBase): - def __init__(self, name): - # type: (Any) -> None + def __init__(self, name: Any) -> None: self.name = name - def get_id(self, version, objectType, symbol): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str, symbol: "Symbol") -> str: if version == 1: raise NoOldIdError() return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: return transform(self.name) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.name.describe_signature(signode, mode, env, symbol=symbol) class ASTEnum(ASTBase): - def __init__(self, name, scoped, underlyingType): - # type: (Any, str, Any) -> None + def __init__(self, name: Any, scoped: str, underlyingType: Any) -> None: self.name = name self.scoped = scoped self.underlyingType = underlyingType - def get_id(self, version, objectType, symbol): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str, symbol: "Symbol") -> str: if version == 1: raise NoOldIdError() return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.scoped: res.append(self.scoped) @@ -3658,8 +3369,8 @@ class ASTEnum(ASTBase): res.append(transform(self.underlyingType)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) # self.scoped has been done by the CPPEnumObject self.name.describe_signature(signode, mode, env, symbol=symbol) @@ -3670,27 +3381,24 @@ class ASTEnum(ASTBase): class ASTEnumerator(ASTBase): - def __init__(self, name, init): - # type: (Any, Any) -> None + def __init__(self, name: Any, init: Any) -> None: self.name = name self.init = init - def get_id(self, version, objectType, symbol): - # type: (int, str, Symbol) -> str + def get_id(self, version: int, objectType: str, symbol: "Symbol") -> str: if version == 1: raise NoOldIdError() return symbol.get_full_nested_name().get_id(version) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] res.append(transform(self.name)) if self.init: res.append(transform(self.init)) return ''.join(res) - def describe_signature(self, signode, mode, env, symbol): - # type: (addnodes.desc_signature, str, BuildEnvironment, Symbol) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: _verify_description_mode(mode) self.name.describe_signature(signode, mode, env, symbol) if self.init: @@ -3698,8 +3406,8 @@ class ASTEnumerator(ASTBase): class ASTDeclaration(ASTBase): - def __init__(self, objectType, directiveType, visibility, templatePrefix, declaration): - # type: (str, str, str, ASTTemplateDeclarationPrefix, Any) -> None + def __init__(self, objectType: str, directiveType: str, visibility: str, + templatePrefix: ASTTemplateDeclarationPrefix, declaration: Any) -> None: self.objectType = objectType self.directiveType = directiveType self.visibility = visibility @@ -3710,8 +3418,7 @@ class ASTDeclaration(ASTBase): # set by CPPObject._add_enumerator_to_parent self.enumeratorScopedSymbol = None # type: Symbol - def clone(self): - # type: () -> ASTDeclaration + def clone(self) -> "ASTDeclaration": if self.templatePrefix: templatePrefixClone = self.templatePrefix.clone() else: @@ -3721,19 +3428,16 @@ class ASTDeclaration(ASTBase): self.declaration.clone()) @property - def name(self): - # type: () -> ASTNestedName + def name(self) -> ASTNestedName: return self.declaration.name @property - def function_params(self): - # type: () -> Any + def function_params(self) -> Any: if self.objectType != 'function': return None return self.declaration.function_params - def get_id(self, version, prefixed=True): - # type: (int, bool) -> str + def get_id(self, version: int, prefixed: bool = True) -> str: if version == 1: if self.templatePrefix: raise NoOldIdError() @@ -3752,12 +3456,10 @@ class ASTDeclaration(ASTBase): res.append(self.declaration.get_id(version, self.objectType, self.symbol)) return ''.join(res) - def get_newest_id(self): - # type: () -> str + def get_newest_id(self) -> str: return self.get_id(_max_id, True) - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.visibility and self.visibility != "public": res.append(self.visibility) @@ -3767,8 +3469,8 @@ class ASTDeclaration(ASTBase): res.append(transform(self.declaration)) return ''.join(res) - def describe_signature(self, signode, mode, env, options): - # type: (addnodes.desc_signature, str, BuildEnvironment, Dict) -> None + def describe_signature(self, signode: desc_signature, mode: str, + env: "BuildEnvironment", options: Dict) -> None: _verify_description_mode(mode) assert self.symbol # The caller of the domain added a desc_signature node. @@ -3821,13 +3523,12 @@ class ASTDeclaration(ASTBase): class ASTNamespace(ASTBase): - def __init__(self, nestedName, templatePrefix): - # type: (ASTNestedName, ASTTemplateDeclarationPrefix) -> None + def __init__(self, nestedName: ASTNestedName, + templatePrefix: ASTTemplateDeclarationPrefix) -> None: self.nestedName = nestedName self.templatePrefix = templatePrefix - def _stringify(self, transform): - # type: (Callable[[Any], str]) -> str + def _stringify(self, transform: StringifyTransform) -> str: res = [] if self.templatePrefix: res.append(transform(self.templatePrefix)) @@ -3836,8 +3537,9 @@ class ASTNamespace(ASTBase): class SymbolLookupResult: - def __init__(self, symbols, parentSymbol, identOrOp, templateParams, templateArgs): - # type: (Iterator[Symbol], Symbol, Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs) -> None # NOQA + def __init__(self, symbols: Iterator["Symbol"], parentSymbol: "Symbol", + identOrOp: Union[ASTIdentifier, ASTOperator], templateParams: Any, + templateArgs: ASTTemplateArgs) -> None: self.symbols = symbols self.parentSymbol = parentSymbol self.identOrOp = identOrOp @@ -3849,8 +3551,7 @@ class Symbol: debug_lookup = False debug_show_tree = False - def _assert_invariants(self): - # type: () -> None + def _assert_invariants(self) -> None: if not self.parent: # parent == None means global scope, so declaration means a parent assert not self.identOrOp @@ -3868,15 +3569,9 @@ class Symbol: else: return super().__setattr__(key, value) - def __init__(self, - parent, # type: Symbol - identOrOp, # type: Union[ASTIdentifier, ASTOperator] - templateParams, # type: Any - templateArgs, # type: Any - declaration, # type: ASTDeclaration - docname # type: str - ): - # type: (...) -> None + def __init__(self, parent: "Symbol", identOrOp: Union[ASTIdentifier, ASTOperator], + templateParams: Any, templateArgs: Any, declaration: ASTDeclaration, + docname: str) -> None: self.parent = parent self.identOrOp = identOrOp self.templateParams = templateParams # template @@ -3898,8 +3593,7 @@ class Symbol: # Do symbol addition after self._children has been initialised. self._add_template_and_function_params() - def _fill_empty(self, declaration, docname): - # type: (ASTDeclaration, str) -> None + def _fill_empty(self, declaration: ASTDeclaration, docname: str) -> None: self._assert_invariants() assert not self.declaration assert not self.docname @@ -3950,8 +3644,7 @@ class Symbol: self.parent._children.remove(self) self.parent = None - def clear_doc(self, docname): - # type: (str) -> None + def clear_doc(self, docname: str) -> None: newChildren = [] for sChild in self._children: sChild.clear_doc(docname) @@ -3961,8 +3654,7 @@ class Symbol: newChildren.append(sChild) self._children = newChildren - def get_all_symbols(self): - # type: () -> Iterator[Any] + def get_all_symbols(self) -> Iterator[Any]: yield self for sChild in self._children: for s in sChild.get_all_symbols(): @@ -3977,8 +3669,7 @@ class Symbol: yield from c.children_recurse_anon - def get_lookup_key(self): - # type: () -> List[Tuple[ASTNestedNameElement, Any]] + def get_lookup_key(self) -> List[Tuple[ASTNestedNameElement, Any]]: symbols = [] s = self while s.parent: @@ -3991,8 +3682,7 @@ class Symbol: key.append((nne, s.templateParams)) return key - def get_full_nested_name(self): - # type: () -> ASTNestedName + def get_full_nested_name(self) -> ASTNestedName: names = [] templates = [] for nne, templateParams in self.get_lookup_key(): @@ -4000,17 +3690,11 @@ class Symbol: templates.append(False) return ASTNestedName(names, templates, rooted=False) - def _find_first_named_symbol( - self, - identOrOp, # type: Union[ASTIdentifier, ASTOperator] - templateParams, # type: Any - templateArgs, # type: ASTTemplateArgs - templateShorthand, # type: bool - matchSelf, # type: bool - recurseInAnon, # type: bool - correctPrimaryTemplateArgs # type: bool - ): # NOQA - # type: (...) -> Symbol + def _find_first_named_symbol(self, identOrOp: Union[ASTIdentifier, ASTOperator], + templateParams: Any, templateArgs: ASTTemplateArgs, + templateShorthand: bool, matchSelf: bool, + recurseInAnon: bool, correctPrimaryTemplateArgs: bool + ) -> "Symbol": res = self._find_named_symbols(identOrOp, templateParams, templateArgs, templateShorthand, matchSelf, recurseInAnon, correctPrimaryTemplateArgs) @@ -4019,16 +3703,11 @@ class Symbol: except StopIteration: return None - def _find_named_symbols(self, - identOrOp, # type: Union[ASTIdentifier, ASTOperator] - templateParams, # type: Any - templateArgs, # type: ASTTemplateArgs - templateShorthand, # type: bool - matchSelf, # type: bool - recurseInAnon, # type: bool - correctPrimaryTemplateArgs # type: bool - ): - # type: (...) -> Iterator[Symbol] + def _find_named_symbols(self, identOrOp: Union[ASTIdentifier, ASTOperator], + templateParams: Any, templateArgs: ASTTemplateArgs, + templateShorthand: bool, matchSelf: bool, + recurseInAnon: bool, correctPrimaryTemplateArgs: bool + ) -> Iterator["Symbol"]: def isSpecialization(): # the names of the template parameters must be given exactly as args @@ -4087,20 +3766,12 @@ class Symbol: if matches(s): yield s - def _symbol_lookup( - self, - nestedName, # type: ASTNestedName - templateDecls, # type: List[Any] - onMissingQualifiedSymbol, - # type: Callable[[Symbol, Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs], Symbol] # NOQA - strictTemplateParamArgLists, # type: bool - ancestorLookupType, # type: str - templateShorthand, # type: bool - matchSelf, # type: bool - recurseInAnon, # type: bool - correctPrimaryTemplateArgs # type: bool - ): - # type: (...) -> SymbolLookupResult + def _symbol_lookup(self, nestedName: ASTNestedName, templateDecls: List[Any], + onMissingQualifiedSymbol: Callable[["Symbol", Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs], "Symbol"], # NOQA + strictTemplateParamArgLists: bool, ancestorLookupType: str, + templateShorthand: bool, matchSelf: bool, + recurseInAnon: bool, correctPrimaryTemplateArgs: bool + ) -> SymbolLookupResult: # ancestorLookupType: if not None, specifies the target type of the lookup if strictTemplateParamArgLists: @@ -4194,8 +3865,8 @@ class Symbol: return SymbolLookupResult(symbols, parentSymbol, identOrOp, templateParams, templateArgs) - def _add_symbols(self, nestedName, templateDecls, declaration, docname): - # type: (ASTNestedName, List[Any], ASTDeclaration, str) -> Symbol + def _add_symbols(self, nestedName: ASTNestedName, templateDecls: List[Any], + declaration: ASTDeclaration, docname: str) -> "Symbol": # Used for adding a whole path of symbols, where the last may or may not # be an actual declaration. @@ -4206,8 +3877,10 @@ class Symbol: print(" decl: ", declaration) print(" doc: ", docname) - def onMissingQualifiedSymbol(parentSymbol, identOrOp, templateParams, templateArgs): - # type: (Symbol, Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs) -> Symbol + def onMissingQualifiedSymbol(parentSymbol: "Symbol", + identOrOp: Union[ASTIdentifier, ASTOperator], + templateParams: Any, templateArgs: ASTTemplateArgs + ) -> "Symbol": if Symbol.debug_lookup: print(" _add_symbols, onMissingQualifiedSymbol:") print(" templateParams:", templateParams) @@ -4346,8 +4019,8 @@ class Symbol: symbol._fill_empty(declaration, docname) return symbol - def merge_with(self, other, docnames, env): - # type: (Symbol, List[str], BuildEnvironment) -> None + def merge_with(self, other: "Symbol", docnames: List[str], + env: "BuildEnvironment") -> None: assert other is not None for otherChild in other._children: ourChild = self._find_first_named_symbol( @@ -4378,8 +4051,8 @@ class Symbol: pass ourChild.merge_with(otherChild, docnames, env) - def add_name(self, nestedName, templatePrefix=None): - # type: (ASTNestedName, ASTTemplateDeclarationPrefix) -> Symbol + def add_name(self, nestedName: ASTNestedName, + templatePrefix: ASTTemplateDeclarationPrefix = None) -> "Symbol": if templatePrefix: templateDecls = templatePrefix.templates else: @@ -4387,8 +4060,7 @@ class Symbol: return self._add_symbols(nestedName, templateDecls, declaration=None, docname=None) - def add_declaration(self, declaration, docname): - # type: (ASTDeclaration, str) -> Symbol + def add_declaration(self, declaration: ASTDeclaration, docname: str) -> "Symbol": assert declaration assert docname nestedName = declaration.name @@ -4398,8 +4070,8 @@ class Symbol: templateDecls = [] return self._add_symbols(nestedName, templateDecls, declaration, docname) - def find_identifier(self, identOrOp, matchSelf, recurseInAnon): - # type: (Union[ASTIdentifier, ASTOperator], bool, bool) -> Symbol + def find_identifier(self, identOrOp: Union[ASTIdentifier, ASTOperator], + matchSelf: bool, recurseInAnon: bool) -> "Symbol": if matchSelf and self.identOrOp == identOrOp: return self children = self.children_recurse_anon if recurseInAnon else self._children @@ -4408,8 +4080,7 @@ class Symbol: return s return None - def direct_lookup(self, key): - # type: (List[Tuple[ASTNestedNameElement, Any]]) -> Symbol + def direct_lookup(self, key: List[Tuple[ASTNestedNameElement, Any]]) -> "Symbol": s = self for name, templateParams in key: identOrOp = name.identOrOp @@ -4424,13 +4095,15 @@ class Symbol: return None return s - def find_name(self, nestedName, templateDecls, typ, templateShorthand, - matchSelf, recurseInAnon): - # type: (ASTNestedName, List[Any], str, bool, bool, bool) -> List[Symbol] + def find_name(self, nestedName: ASTNestedName, templateDecls: List[Any], + typ: str, templateShorthand: bool, matchSelf: bool, + recurseInAnon: bool) -> List["Symbol"]: # templateShorthand: missing template parameter lists for templates is ok - def onMissingQualifiedSymbol(parentSymbol, identOrOp, templateParams, templateArgs): - # type: (Symbol, Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs) -> Symbol + def onMissingQualifiedSymbol(parentSymbol: "Symbol", + identOrOp: Union[ASTIdentifier, ASTOperator], + templateParams: Any, + templateArgs: ASTTemplateArgs) -> "Symbol": # TODO: Maybe search without template args? # Though, the correctPrimaryTemplateArgs does # that for primary templates. @@ -4463,9 +4136,8 @@ class Symbol: else: return None - def find_declaration(self, declaration, typ, templateShorthand, - matchSelf, recurseInAnon): - # type: (ASTDeclaration, str, bool, bool, bool) -> Symbol + def find_declaration(self, declaration: ASTDeclaration, typ: str, templateShorthand: bool, + matchSelf: bool, recurseInAnon: bool) -> "Symbol": # templateShorthand: missing template parameter lists for templates is ok nestedName = declaration.name if declaration.templatePrefix: @@ -4473,8 +4145,10 @@ class Symbol: else: templateDecls = [] - def onMissingQualifiedSymbol(parentSymbol, identOrOp, templateParams, templateArgs): - # type: (Symbol, Union[ASTIdentifier, ASTOperator], Any, ASTTemplateArgs) -> Symbol + def onMissingQualifiedSymbol(parentSymbol: "Symbol", + identOrOp: Union[ASTIdentifier, ASTOperator], + templateParams: Any, + templateArgs: ASTTemplateArgs) -> "Symbol": return None lookupResult = self._symbol_lookup(nestedName, templateDecls, @@ -4510,8 +4184,7 @@ class Symbol: querySymbol.remove() return None - def to_string(self, indent): - # type: (int) -> str + def to_string(self, indent: int) -> str: res = ['\t' * indent] if not self.parent: res.append('::') @@ -4538,8 +4211,7 @@ class Symbol: res.append('\n') return ''.join(res) - def dump(self, indent): - # type: (int) -> str + def dump(self, indent: int) -> str: res = [self.to_string(indent)] for c in self._children: res.append(c.dump(indent + 1)) @@ -4556,8 +4228,7 @@ class DefinitionParser: _prefix_keys = ('class', 'struct', 'enum', 'union', 'typename') - def __init__(self, definition, warnEnv, config): - # type: (Any, Any, Config) -> None + def __init__(self, definition: Any, warnEnv: Any, config: "Config") -> None: self.definition = definition.strip() self.pos = 0 self.end = len(self.definition) @@ -4570,8 +4241,7 @@ class DefinitionParser: self.warnEnv = warnEnv self.config = config - def _make_multi_error(self, errors, header): - # type: (List[Any], str) -> DefinitionError + def _make_multi_error(self, errors: List[Any], header: str) -> DefinitionError: if len(errors) == 1: if len(header) > 0: return DefinitionError(header + '\n' + str(errors[0][0])) @@ -4593,14 +4263,12 @@ class DefinitionParser: result.append(str(e[0])) return DefinitionError(''.join(result)) - def status(self, msg): - # type: (str) -> None + def status(self, msg: str) -> None: # for debugging indicator = '-' * self.pos + '^' print("%s\n%s\n%s" % (msg, self.definition, indicator)) - def fail(self, msg): - # type: (str) -> None + def fail(self, msg: str) -> None: errors = [] indicator = '-' * self.pos + '^' exMain = DefinitionError( @@ -4612,15 +4280,13 @@ class DefinitionParser: self.otherErrors = [] raise self._make_multi_error(errors, '') - def warn(self, msg): - # type: (str) -> None + def warn(self, msg: str) -> None: if self.warnEnv: self.warnEnv.warn(msg) else: print("Warning: %s" % msg) - def match(self, regex): - # type: (Pattern) -> bool + def match(self, regex: Pattern) -> bool: match = regex.match(self.definition, self.pos) if match is not None: self._previous_state = (self.pos, self.last_match) @@ -4629,69 +4295,58 @@ class DefinitionParser: return True return False - def backout(self): - # type: () -> None + def backout(self) -> None: self.pos, self.last_match = self._previous_state - def skip_string(self, string): - # type: (str) -> bool + def skip_string(self, string: str) -> bool: strlen = len(string) if self.definition[self.pos:self.pos + strlen] == string: self.pos += strlen return True return False - def skip_word(self, word): - # type: (str) -> bool + def skip_word(self, word: str) -> bool: return self.match(re.compile(r'\b%s\b' % re.escape(word))) - def skip_ws(self): - # type: () -> bool + def skip_ws(self) -> bool: return self.match(_whitespace_re) - def skip_word_and_ws(self, word): - # type: (str) -> bool + def skip_word_and_ws(self, word: str) -> bool: if self.skip_word(word): self.skip_ws() return True return False - def skip_string_and_ws(self, string): - # type: (str) -> bool + def skip_string_and_ws(self, string: str) -> bool: if self.skip_string(string): self.skip_ws() return True return False @property - def eof(self): - # type: () -> bool + def eof(self) -> bool: return self.pos >= self.end @property - def current_char(self): - # type: () -> str + def current_char(self) -> str: try: return self.definition[self.pos] except IndexError: return 'EOF' @property - def matched_text(self): - # type: () -> str + def matched_text(self) -> str: if self.last_match is not None: return self.last_match.group() else: return None - def read_rest(self): - # type: () -> str + def read_rest(self) -> str: rv = self.definition[self.pos:] self.pos = self.end return rv - def assert_end(self): - # type: () -> None + def assert_end(self) -> None: self.skip_ws() if not self.eof: self.fail('Expected end of definition.') @@ -4715,8 +4370,7 @@ class DefinitionParser: self.pos += 1 return self.definition[startPos:self.pos] - def _parse_balanced_token_seq(self, end): - # type: (List[str]) -> str + def _parse_balanced_token_seq(self, end: List[str]) -> str: # TODO: add handling of string literals and similar brackets = {'(': ')', '[': ']', '{': '}'} startPos = self.pos @@ -4736,8 +4390,7 @@ class DefinitionParser: % startPos) return self.definition[startPos:self.pos] - def _parse_attribute(self): - # type: () -> Any + def _parse_attribute(self) -> Any: self.skip_ws() # try C++11 style startPos = self.pos @@ -4917,8 +4570,8 @@ class DefinitionParser: return res return self._parse_nested_name() - def _parse_initializer_list(self, name, open, close): - # type: (str, str, str) -> Tuple[List[Any], bool] + def _parse_initializer_list(self, name: str, open: str, close: str + ) -> Tuple[List[Any], bool]: # Parse open and close with the actual initializer-list inbetween # -> initializer-clause '...'[opt] # | initializer-list ',' initializer-clause '...'[opt] @@ -4949,8 +4602,7 @@ class DefinitionParser: break return exprs, trailingComma - def _parse_paren_expression_list(self): - # type: () -> ASTParenExprList + def _parse_paren_expression_list(self) -> ASTParenExprList: # -> '(' expression-list ')' # though, we relax it to also allow empty parens # as it's needed in some cases @@ -4963,8 +4615,7 @@ class DefinitionParser: return None return ASTParenExprList(exprs) - def _parse_braced_init_list(self): - # type: () -> ASTBracedInitList + def _parse_braced_init_list(self) -> ASTBracedInitList: # -> '{' initializer-list ','[opt] '}' # | '{' '}' exprs, trailingComma = self._parse_initializer_list("braced-init-list", '{', '}') @@ -4972,8 +4623,9 @@ class DefinitionParser: return None return ASTBracedInitList(exprs, trailingComma) - def _parse_expression_list_or_braced_init_list(self): - # type: () -> Union[ASTParenExprList, ASTBracedInitList] + def _parse_expression_list_or_braced_init_list( + self + ) -> Union[ASTParenExprList, ASTBracedInitList]: paren = self._parse_paren_expression_list() if paren is not None: return paren @@ -5382,8 +5034,7 @@ class DefinitionParser: value = self.definition[startPos:self.pos].strip() return ASTFallbackExpr(value.strip()) - def _parse_operator(self): - # type: () -> ASTOperator + def _parse_operator(self) -> ASTOperator: self.skip_ws() # adapted from the old code # thank god, a regular operator definition @@ -5415,8 +5066,7 @@ class DefinitionParser: type = self._parse_type(named=False, outer="operatorCast") return ASTOperatorType(type) - def _parse_template_argument_list(self): - # type: () -> ASTTemplateArgs + def _parse_template_argument_list(self) -> ASTTemplateArgs: self.skip_ws() if not self.skip_string_and_ws('<'): return None @@ -5463,8 +5113,7 @@ class DefinitionParser: break return ASTTemplateArgs(templateArgs) - def _parse_nested_name(self, memberPointer=False): - # type: (bool) -> ASTNestedName + def _parse_nested_name(self, memberPointer: bool = False) -> ASTNestedName: names = [] # type: List[Any] templates = [] # type: List[bool] @@ -5512,8 +5161,7 @@ class DefinitionParser: break return ASTNestedName(names, templates, rooted) - def _parse_trailing_type_spec(self): - # type: () -> Any + def _parse_trailing_type_spec(self) -> Any: # fundemental types self.skip_ws() for t in self._simple_fundemental_types: @@ -5568,8 +5216,7 @@ class DefinitionParser: nestedName = self._parse_nested_name() return ASTTrailingTypeSpecName(prefix, nestedName) - def _parse_parameters_and_qualifiers(self, paramMode): - # type: (str) -> ASTParametersQualifiers + def _parse_parameters_and_qualifiers(self, paramMode: str) -> ASTParametersQualifiers: if paramMode == 'new': return None self.skip_ws() @@ -5660,8 +5307,7 @@ class DefinitionParser: args, volatile, const, refQual, exceptionSpec, override, final, initializer) - def _parse_decl_specs_simple(self, outer, typed): - # type: (str, bool) -> ASTDeclSpecsSimple + def _parse_decl_specs_simple(self, outer: str, typed: bool) -> ASTDeclSpecsSimple: """Just parse the simple ones.""" storage = None threadLocal = None @@ -5735,8 +5381,7 @@ class DefinitionParser: explicit, constexpr, volatile, const, friend, attrs) - def _parse_decl_specs(self, outer, typed=True): - # type: (str, bool) -> ASTDeclSpecs + def _parse_decl_specs(self, outer: str, typed: bool = True) -> ASTDeclSpecs: if outer: if outer not in ('type', 'member', 'function', 'templateParam'): raise Exception('Internal error, unknown outer "%s".' % outer) @@ -5763,12 +5408,9 @@ class DefinitionParser: trailing = None return ASTDeclSpecs(outer, leftSpecs, rightSpecs, trailing) - def _parse_declarator_name_suffix(self, - named, # type: Union[bool, str] - paramMode, # type: str - typed # type: bool - ): - # type: (...) -> Union[ASTDeclaratorNameParamQual, ASTDeclaratorNameBitField] + def _parse_declarator_name_suffix( + self, named: Union[bool, str], paramMode: str, typed: bool + ) -> Union[ASTDeclaratorNameParamQual, ASTDeclaratorNameBitField]: # now we should parse the name, and then suffixes if named == 'maybe': pos = self.pos @@ -5821,8 +5463,8 @@ class DefinitionParser: return ASTDeclaratorNameParamQual(declId=declId, arrayOps=arrayOps, paramQual=paramQual) - def _parse_declarator(self, named, paramMode, typed=True): - # type: (Union[bool, str], str, bool) -> Any + def _parse_declarator(self, named: Union[bool, str], paramMode: str, + typed: bool = True) -> Any: # 'typed' here means 'parse return type stuff' if paramMode not in ('type', 'function', 'operatorCast', 'new'): raise Exception( @@ -5933,8 +5575,8 @@ class DefinitionParser: header = "Error in declarator or parameters and qualifiers" raise self._make_multi_error(prevErrors, header) - def _parse_initializer(self, outer=None, allowFallback=True): - # type: (str, bool) -> ASTInitializer + def _parse_initializer(self, outer: str = None, allowFallback: bool = True + ) -> ASTInitializer: # initializer # global vars # -> brace-or-equal-initializer # | '(' expression-list ')' @@ -5982,8 +5624,7 @@ class DefinitionParser: value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback) return ASTInitializer(value) - def _parse_type(self, named, outer=None): - # type: (Union[bool, str], str) -> ASTType + def _parse_type(self, named: Union[bool, str], outer: str = None) -> ASTType: """ named=False|'maybe'|True: 'maybe' is e.g., for function objects which doesn't need to name the arguments @@ -6065,8 +5706,7 @@ class DefinitionParser: decl = self._parse_declarator(named=named, paramMode=paramMode) return ASTType(declSpecs, decl) - def _parse_type_with_init(self, named, outer): - # type: (Union[bool, str], str) -> Any + def _parse_type_with_init(self, named: Union[bool, str], outer: str) -> Any: if outer: assert outer in ('type', 'member', 'function', 'templateParam') type = self._parse_type(outer=outer, named=named) @@ -6109,8 +5749,7 @@ class DefinitionParser: msg += " or constrianted template paramter." raise self._make_multi_error(errs, msg) - def _parse_type_using(self): - # type: () -> ASTTypeUsing + def _parse_type_using(self) -> ASTTypeUsing: name = self._parse_nested_name() self.skip_ws() if not self.skip_string('='): @@ -6118,15 +5757,13 @@ class DefinitionParser: type = self._parse_type(False, None) return ASTTypeUsing(name, type) - def _parse_concept(self): - # type: () -> ASTConcept + def _parse_concept(self) -> ASTConcept: nestedName = self._parse_nested_name() self.skip_ws() initializer = self._parse_initializer('member') return ASTConcept(nestedName, initializer) - def _parse_class(self): - # type: () -> ASTClass + def _parse_class(self) -> ASTClass: name = self._parse_nested_name() self.skip_ws() final = self.skip_word_and_ws('final') @@ -6156,13 +5793,11 @@ class DefinitionParser: break return ASTClass(name, final, bases) - def _parse_union(self): - # type: () -> ASTUnion + def _parse_union(self) -> ASTUnion: name = self._parse_nested_name() return ASTUnion(name) - def _parse_enum(self): - # type: () -> ASTEnum + def _parse_enum(self) -> ASTEnum: scoped = None # is set by CPPEnumObject self.skip_ws() name = self._parse_nested_name() @@ -6172,8 +5807,7 @@ class DefinitionParser: underlyingType = self._parse_type(named=False) return ASTEnum(name, scoped, underlyingType) - def _parse_enumerator(self): - # type: () -> ASTEnumerator + def _parse_enumerator(self) -> ASTEnumerator: name = self._parse_nested_name() self.skip_ws() init = None @@ -6186,8 +5820,7 @@ class DefinitionParser: init = ASTInitializer(initVal) return ASTEnumerator(name, init) - def _parse_template_parameter_list(self): - # type: () -> ASTTemplateParams + def _parse_template_parameter_list(self) -> "ASTTemplateParams": # only: '<' parameter-list '>' # we assume that 'template' has just been parsed templateParams = [] # type: List @@ -6258,8 +5891,7 @@ class DefinitionParser: prevErrors.append((e, "")) raise self._make_multi_error(prevErrors, header) - def _parse_template_introduction(self): - # type: () -> ASTTemplateIntroduction + def _parse_template_introduction(self) -> "ASTTemplateIntroduction": pos = self.pos try: concept = self._parse_nested_name() @@ -6297,8 +5929,8 @@ class DefinitionParser: 'Expected ",", or "}".') return ASTTemplateIntroduction(concept, params) - def _parse_template_declaration_prefix(self, objectType): - # type: (str) -> ASTTemplateDeclarationPrefix + def _parse_template_declaration_prefix(self, objectType: str + ) -> ASTTemplateDeclarationPrefix: templates = [] # type: List[str] while 1: self.skip_ws() @@ -6327,13 +5959,10 @@ class DefinitionParser: else: return ASTTemplateDeclarationPrefix(templates) - def _check_template_consistency(self, - nestedName, # type: ASTNestedName - templatePrefix, # type: ASTTemplateDeclarationPrefix - fullSpecShorthand, # type: bool - isMember=False # type: bool - ): - # type: (...) -> ASTTemplateDeclarationPrefix + def _check_template_consistency(self, nestedName: ASTNestedName, + templatePrefix: ASTTemplateDeclarationPrefix, + fullSpecShorthand: bool, isMember: bool = False + ) -> ASTTemplateDeclarationPrefix: numArgs = nestedName.num_templates() isMemberInstantiation = False if not templatePrefix: @@ -6369,8 +5998,7 @@ class DefinitionParser: templatePrefix = ASTTemplateDeclarationPrefix(newTemplates) return templatePrefix - def parse_declaration(self, objectType, directiveType): - # type: (str, str) -> ASTDeclaration + def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration: if objectType not in ('class', 'union', 'function', 'member', 'type', 'concept', 'enum', 'enumerator'): raise Exception('Internal error, unknown objectType "%s".' % objectType) @@ -6430,8 +6058,7 @@ class DefinitionParser: return ASTDeclaration(objectType, directiveType, visibility, templatePrefix, declaration) - def parse_namespace_object(self): - # type: () -> ASTNamespace + def parse_namespace_object(self) -> ASTNamespace: templatePrefix = self._parse_template_declaration_prefix(objectType="namespace") name = self._parse_nested_name() templatePrefix = self._check_template_consistency(name, templatePrefix, @@ -6440,8 +6067,7 @@ class DefinitionParser: res.objectType = 'namespace' # type: ignore return res - def parse_xref_object(self): - # type: () -> Tuple[Any, bool] + def parse_xref_object(self) -> Tuple[Any, bool]: pos = self.pos try: templatePrefix = self._parse_template_declaration_prefix(objectType="xref") @@ -6492,8 +6118,7 @@ class DefinitionParser: return expr -def _make_phony_error_name(): - # type: () -> ASTNestedName +def _make_phony_error_name() -> ASTNestedName: nne = ASTNestedNameElement(ASTIdentifier("PhonyNameDueToError"), None) return ASTNestedName([nne], [False], rooted=False) @@ -6518,12 +6143,10 @@ class CPPObject(ObjectDescription): option_spec = dict(ObjectDescription.option_spec) option_spec['tparam-line-spec'] = directives.flag - def warn(self, msg): - # type: (Union[str, Exception]) -> None + def warn(self, msg: Union[str, Exception]) -> None: self.state_machine.reporter.warning(msg, line=self.lineno) - def _add_enumerator_to_parent(self, ast): - # type: (ASTDeclaration) -> None + def _add_enumerator_to_parent(self, ast: ASTDeclaration) -> None: assert ast.objectType == 'enumerator' # find the parent, if it exists && is an enum # && it's unscoped, @@ -6564,8 +6187,8 @@ class CPPObject(ObjectDescription): declaration=declClone, docname=self.env.docname) - def add_target_and_index(self, ast, sig, signode): - # type: (ASTDeclaration, str, addnodes.desc_signature) -> None + def add_target_and_index(self, ast: ASTDeclaration, sig: str, signode: desc_signature + ) -> None: # general note: name must be lstrip(':')'ed, to remove "::" ids = [] for i in range(1, _max_id + 1): @@ -6625,25 +6248,20 @@ class CPPObject(ObjectDescription): self.state.document.note_explicit_target(signode) @property - def object_type(self): - # type: () -> str + def object_type(self) -> str: raise NotImplementedError() @property - def display_object_type(self): - # type: () -> str + def display_object_type(self) -> str: return self.object_type - def get_index_text(self, name): - # type: (str) -> str + def get_index_text(self, name: str) -> str: return _('%s (C++ %s)') % (name, self.display_object_type) - def parse_definition(self, parser): - # type: (DefinitionParser) -> ASTDeclaration + def parse_definition(self, parser: DefinitionParser) -> ASTDeclaration: return parser.parse_declaration(self.object_type, self.objtype) - def describe_signature(self, signode, ast, options): - # type: (addnodes.desc_signature, Any, Dict) -> None + def describe_signature(self, signode: desc_signature, ast: Any, options: Dict) -> None: ast.describe_signature(signode, 'lastIsName', self.env, options) def run(self): @@ -6675,8 +6293,7 @@ class CPPObject(ObjectDescription): return [] return super().run() - def handle_signature(self, sig, signode): - # type: (str, addnodes.desc_signature) -> ASTDeclaration + def handle_signature(self, sig: str, signode: desc_signature) -> ASTDeclaration: parentSymbol = self.env.temp_data['cpp:parent_symbol'] parser = DefinitionParser(sig, self, self.env.config) @@ -6711,8 +6328,7 @@ class CPPObject(ObjectDescription): self.describe_signature(signode, ast, options) return ast - def before_content(self): - # type: () -> None + def before_content(self) -> None: lastSymbol = self.env.temp_data['cpp:last_symbol'] assert lastSymbol self.oldParentSymbol = self.env.temp_data['cpp:parent_symbol'] @@ -6720,8 +6336,7 @@ class CPPObject(ObjectDescription): self.env.temp_data['cpp:parent_symbol'] = lastSymbol self.env.ref_context['cpp:parent_key'] = lastSymbol.get_lookup_key() - def after_content(self): - # type: () -> None + def after_content(self) -> None: self.env.temp_data['cpp:parent_symbol'] = self.oldParentSymbol self.env.ref_context['cpp:parent_key'] = self.oldParentKey @@ -6776,12 +6391,10 @@ class CPPNamespaceObject(SphinxDirective): final_argument_whitespace = True option_spec = {} # type: Dict - def warn(self, msg): - # type: (Union[str, Exception]) -> None + def warn(self, msg: Union[str, Exception]) -> None: self.state_machine.reporter.warning(msg, line=self.lineno) - def run(self): - # type: () -> List[nodes.Node] + def run(self) -> List[Node]: rootSymbol = self.env.domaindata['cpp']['root_symbol'] if self.arguments[0].strip() in ('NULL', '0', 'nullptr'): symbol = rootSymbol @@ -6810,12 +6423,10 @@ class CPPNamespacePushObject(SphinxDirective): final_argument_whitespace = True option_spec = {} # type: Dict - def warn(self, msg): - # type: (Union[str, Exception]) -> None + def warn(self, msg: Union[str, Exception]) -> None: self.state_machine.reporter.warning(msg, line=self.lineno) - def run(self): - # type: () -> List[nodes.Node] + def run(self) -> List[Node]: if self.arguments[0].strip() in ('NULL', '0', 'nullptr'): return [] parser = DefinitionParser(self.arguments[0], self, self.config) @@ -6845,12 +6456,10 @@ class CPPNamespacePopObject(SphinxDirective): final_argument_whitespace = True option_spec = {} # type: Dict - def warn(self, msg): - # type: (Union[str, Exception]) -> None + def warn(self, msg: Union[str, Exception]) -> None: self.state_machine.reporter.warning(msg, line=self.lineno) - def run(self): - # type: () -> List[nodes.Node] + def run(self) -> List[Node]: stack = self.env.temp_data.get('cpp:namespace_stack', None) if not stack or len(stack) == 0: self.warn("C++ namespace pop on empty stack. Defaulting to gobal scope.") @@ -6887,8 +6496,7 @@ class AliasNode(nodes.Element): class AliasTransform(SphinxTransform): default_priority = ReferencesResolver.default_priority - 1 - def apply(self, **kwargs): - # type: (Any) -> None + def apply(self, **kwargs) -> None: for node in self.document.traverse(AliasNode): class Warner: def warn(self, msg): @@ -6970,8 +6578,7 @@ class AliasTransform(SphinxTransform): class CPPAliasObject(ObjectDescription): option_spec = {} # type: Dict - def run(self): - # type: () -> List[nodes.Node] + def run(self) -> List[Node]: """ On purpose this doesn't call the ObjectDescription version, but is based on it. Each alias signature may expand into multiple real signatures (an overload set). @@ -7004,8 +6611,8 @@ class CPPAliasObject(ObjectDescription): class CPPXRefRole(XRefRole): - def process_link(self, env, refnode, has_explicit_title, title, target): - # type: (BuildEnvironment, nodes.Element, bool, str, str) -> Tuple[str, str] + def process_link(self, env: BuildEnvironment, refnode: Element, has_explicit_title: bool, + title: str, target: str) -> Tuple[str, str]: refnode.attributes.update(env.ref_context) if not has_explicit_title: @@ -7135,8 +6742,7 @@ class CPPDomain(Domain): 'names': {} # full name for indexing -> docname } - def clear_doc(self, docname): - # type: (str) -> None + def clear_doc(self, docname: str) -> None: if Symbol.debug_show_tree: print("clear_doc:", docname) print("\tbefore:") @@ -7155,19 +6761,17 @@ class CPPDomain(Domain): if nDocname == docname: del self.data['names'][name] - def process_doc(self, env, docname, document): - # type: (BuildEnvironment, str, nodes.document) -> None + def process_doc(self, env: BuildEnvironment, docname: str, + document: nodes.document) -> None: if Symbol.debug_show_tree: print("process_doc:", docname) print(self.data['root_symbol'].dump(0)) print("process_doc end:", docname) - def process_field_xref(self, pnode): - # type: (addnodes.pending_xref) -> None + def process_field_xref(self, pnode: pending_xref) -> None: pnode.attributes.update(self.env.ref_context) - def merge_domaindata(self, docnames, otherdata): - # type: (List[str], Dict) -> None + def merge_domaindata(self, docnames: List[str], otherdata: Dict) -> None: if Symbol.debug_show_tree: print("merge_domaindata:") print("\tself:") @@ -7191,9 +6795,9 @@ class CPPDomain(Domain): else: ourNames[name] = docname - def _resolve_xref_inner(self, env, fromdocname, builder, typ, - target, node, contnode, emitWarnings=True): - # type: (BuildEnvironment, str, Builder, str, str, addnodes.pending_xref, nodes.Element, bool) -> Tuple[nodes.Element, str] # NOQA + def _resolve_xref_inner(self, env: BuildEnvironment, fromdocname: str, builder: Builder, + typ: str, target: str, node: pending_xref, contnode: Element, + emitWarnings: bool = True) -> Tuple[Element, str]: class Warner: def warn(self, msg): if emitWarnings: @@ -7329,13 +6933,15 @@ class CPPDomain(Domain): declaration.get_newest_id(), contnode, displayName ), declaration.objectType - def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): - # type: (BuildEnvironment, str, Builder, str, str, addnodes.pending_xref, nodes.Element) -> nodes.Element # NOQA + def resolve_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder, + typ: str, target: str, node: pending_xref, contnode: Element + ) -> Element: return self._resolve_xref_inner(env, fromdocname, builder, typ, target, node, contnode)[0] - def resolve_any_xref(self, env, fromdocname, builder, target, node, contnode): - # type: (BuildEnvironment, str, Builder, str, addnodes.pending_xref, nodes.Element) -> List[Tuple[str, nodes.Element]] # NOQA + def resolve_any_xref(self, env: BuildEnvironment, fromdocname: str, builder: Builder, + target: str, node: pending_xref, contnode: Element + ) -> List[Tuple[str, Element]]: retnode, objtype = self._resolve_xref_inner(env, fromdocname, builder, 'any', target, node, contnode, emitWarnings=False) @@ -7346,8 +6952,7 @@ class CPPDomain(Domain): return [('cpp:' + self.role_for_objtype(objtype), retnode)] return [] - def get_objects(self): - # type: () -> Iterator[Tuple[str, str, str, str, str, int]] + def get_objects(self) -> Iterator[Tuple[str, str, str, str, str, int]]: rootSymbol = self.data['root_symbol'] for symbol in rootSymbol.get_all_symbols(): if symbol.declaration is None: @@ -7361,8 +6966,7 @@ class CPPDomain(Domain): newestId = symbol.declaration.get_newest_id() yield (name, dispname, objectType, docname, newestId, 1) - def get_full_qualified_name(self, node): - # type: (nodes.Element) -> str + def get_full_qualified_name(self, node: Element) -> str: target = node.get('reftarget', None) if target is None: return None @@ -7376,8 +6980,7 @@ class CPPDomain(Domain): return '::'.join([str(parentName), target]) -def setup(app): - # type: (Sphinx) -> Dict[str, Any] +def setup(app: Sphinx) -> Dict[str, Any]: app.add_domain(CPPDomain) app.add_config_value("cpp_index_common_prefix", [], 'env') app.add_config_value("cpp_id_attributes", [], 'env') From c171702ee26ebbf833a00240b9ddd355963af0f5 Mon Sep 17 00:00:00 2001 From: Takeshi KOMIYA Date: Wed, 25 Dec 2019 23:41:54 +0900 Subject: [PATCH 08/22] Stop to use deprecated API: env.indexentries --- sphinx/writers/texinfo.py | 4 +++- tests/test_environment_indexentries.py | 18 ++++++------------ 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/sphinx/writers/texinfo.py b/sphinx/writers/texinfo.py index bb4c2e23c..ad7f36588 100644 --- a/sphinx/writers/texinfo.py +++ b/sphinx/writers/texinfo.py @@ -21,6 +21,7 @@ from docutils.nodes import Element, Node, Text from sphinx import addnodes, __display_version__ from sphinx.deprecation import RemovedInSphinx30Warning from sphinx.domains import IndexEntry +from sphinx.domains.index import IndexDomain from sphinx.errors import ExtensionError from sphinx.locale import admonitionlabels, _, __ from sphinx.util import logging @@ -497,8 +498,9 @@ class TexinfoTranslator(SphinxTranslator): self.indices.append((indexcls.localname, generate(content, collapsed))) # only add the main Index if it's not empty + domain = cast(IndexDomain, self.builder.env.get_domain('index')) for docname in self.builder.docnames: - if self.builder.env.indexentries[docname]: + if domain.entries[docname]: self.indices.append((_('Index'), '\n@printindex ge\n')) break diff --git a/tests/test_environment_indexentries.py b/tests/test_environment_indexentries.py index 5c0ab7849..cf4a52c24 100644 --- a/tests/test_environment_indexentries.py +++ b/tests/test_environment_indexentries.py @@ -14,9 +14,8 @@ from sphinx.environment.adapters.indexentries import IndexEntries from sphinx.testing import restructuredtext -@pytest.mark.sphinx('dummy') +@pytest.mark.sphinx('dummy', freshenv=True) def test_create_single_index(app): - app.env.indexentries.clear() text = (".. index:: docutils\n" ".. index:: Python\n" ".. index:: pip; install\n" @@ -42,9 +41,8 @@ def test_create_single_index(app): assert index[5] == ('ת', [('‏תירבע‎', [[('', '#index-7')], [], None])]) -@pytest.mark.sphinx('dummy') +@pytest.mark.sphinx('dummy', freshenv=True) def test_create_pair_index(app): - app.env.indexentries.clear() text = (".. index:: pair: docutils; reStructuredText\n" ".. index:: pair: Python; interpreter\n" ".. index:: pair: Sphinx; documentation tool\n" @@ -73,9 +71,8 @@ def test_create_pair_index(app): ('Ель', [[], [('Sphinx', [('', '#index-4')])], None])]) -@pytest.mark.sphinx('dummy') +@pytest.mark.sphinx('dummy', freshenv=True) def test_create_triple_index(app): - app.env.indexentries.clear() text = (".. index:: triple: foo; bar; baz\n" ".. index:: triple: Python; Sphinx; reST\n") restructuredtext.parse(app, text) @@ -89,9 +86,8 @@ def test_create_triple_index(app): assert index[4] == ('S', [('Sphinx', [[], [('reST, Python', [('', '#index-1')])], None])]) -@pytest.mark.sphinx('dummy') +@pytest.mark.sphinx('dummy', freshenv=True) def test_create_see_index(app): - app.env.indexentries.clear() text = (".. index:: see: docutils; reStructuredText\n" ".. index:: see: Python; interpreter\n" ".. index:: see: Sphinx; documentation tool\n") @@ -103,9 +99,8 @@ def test_create_see_index(app): assert index[2] == ('S', [('Sphinx', [[], [('see documentation tool', [])], None])]) -@pytest.mark.sphinx('dummy') +@pytest.mark.sphinx('dummy', freshenv=True) def test_create_seealso_index(app): - app.env.indexentries.clear() text = (".. index:: seealso: docutils; reStructuredText\n" ".. index:: seealso: Python; interpreter\n" ".. index:: seealso: Sphinx; documentation tool\n") @@ -117,9 +112,8 @@ def test_create_seealso_index(app): assert index[2] == ('S', [('Sphinx', [[], [('see also documentation tool', [])], None])]) -@pytest.mark.sphinx('dummy') +@pytest.mark.sphinx('dummy', freshenv=True) def test_create_index_by_key(app): - app.env.indexentries.clear() # At present, only glossary directive is able to create index key text = (".. glossary::\n" "\n" From 0fa399c28792839b0dac45d3a1a365eef4fbfddf Mon Sep 17 00:00:00 2001 From: Takeshi KOMIYA Date: Thu, 26 Dec 2019 00:56:06 +0900 Subject: [PATCH 09/22] Fix #6961: latex: warning for babel shown twice --- CHANGES | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGES b/CHANGES index ed25bbc85..21c12cbf2 100644 --- a/CHANGES +++ b/CHANGES @@ -28,6 +28,7 @@ Bugs fixed * #6925: html: Remove redundant type="text/javascript" from