From b3f085aa08a6abbf8199b5b5dcb3a51c5259e936 Mon Sep 17 00:00:00 2001
From: Takeshi KOMIYA <i.tkomiya@gmail.com>
Date: Wed, 21 Nov 2018 01:10:26 +0900
Subject: [PATCH] Update type hints to LaTeX writer

---
 sphinx/writers/latex.py | 401 ++++++++++++++++++++--------------------
 1 file changed, 201 insertions(+), 200 deletions(-)

diff --git a/sphinx/writers/latex.py b/sphinx/writers/latex.py
index 04d567ad8..5b9f5e75b 100644
--- a/sphinx/writers/latex.py
+++ b/sphinx/writers/latex.py
@@ -43,6 +43,7 @@ if False:
     # For type annotation
     from typing import Any, Callable, Dict, Iterator, List, Pattern, Tuple, Set, Union  # NOQA
     from sphinx.builders.latex import LaTeXBuilder  # NOQA
+    from sphinx.builders.latex import nodes as latexnodes  # NOQA
 
 logger = logging.getLogger(__name__)
 
@@ -823,7 +824,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         return LaTeXRenderer().render(template_name, variables)
 
     def visit_document(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.document) -> None
         self.curfilestack.append(node.get('docname', ''))
         if self.first_document == 1:
             # the first document is all the regular content ...
@@ -838,11 +839,11 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.sectionlevel = self.top_sectionlevel - 1
 
     def depart_document(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.document) -> None
         pass
 
     def visit_start_of_file(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.start_of_file) -> None
         self.curfilestack.append(node['docname'])
 
     def collect_footnotes(self, node):
@@ -866,60 +867,60 @@ class LaTeXTranslator(nodes.NodeVisitor):
         return fnotes
 
     def depart_start_of_file(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.start_of_file) -> None
         self.curfilestack.pop()
 
     def visit_section(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.section) -> None
         if not self.this_is_the_title:
             self.sectionlevel += 1
         self.body.append('\n\n')
 
     def depart_section(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.section) -> None
         self.sectionlevel = max(self.sectionlevel - 1,
                                 self.top_sectionlevel - 1)
 
     def visit_problematic(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.problematic) -> None
         self.body.append(r'{\color{red}\bfseries{}')
 
     def depart_problematic(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.problematic) -> None
         self.body.append('}')
 
     def visit_topic(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.topic) -> None
         self.in_minipage = 1
         self.body.append('\n\\begin{sphinxShadowBox}\n')
 
     def depart_topic(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.topic) -> None
         self.in_minipage = 0
         self.body.append('\\end{sphinxShadowBox}\n')
     visit_sidebar = visit_topic
     depart_sidebar = depart_topic
 
     def visit_glossary(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.glossary) -> None
         pass
 
     def depart_glossary(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.glossary) -> None
         pass
 
     def visit_productionlist(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.productionlist) -> None
         self.body.append('\n\n\\begin{productionlist}\n')
         self.in_production_list = 1
 
     def depart_productionlist(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.productionlist) -> None
         self.body.append('\\end{productionlist}\n\n')
         self.in_production_list = 0
 
     def visit_production(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.production) -> None
         if node['tokenname']:
             tn = node['tokenname']
             self.body.append(self.hypertarget('grammar-token-' + tn))
@@ -928,19 +929,19 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append('\\productioncont{')
 
     def depart_production(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.production) -> None
         self.body.append('}\n')
 
     def visit_transition(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.transition) -> None
         self.body.append(self.elements['transition'])
 
     def depart_transition(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.transition) -> None
         pass
 
     def visit_title(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.title) -> None
         parent = node.parent
         if isinstance(parent, addnodes.seealso):
             # the environment already handles this
@@ -990,7 +991,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.in_title = 1
 
     def depart_title(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.title) -> None
         self.in_title = 0
         if isinstance(node.parent, nodes.table):
             self.table.caption = self.popbody()
@@ -998,7 +999,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append(self.context.pop())
 
     def visit_subtitle(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.subtitle) -> None
         if isinstance(node.parent, nodes.sidebar):
             self.body.append('\\sphinxstylesidebarsubtitle{')
             self.context.append('}\n')
@@ -1006,17 +1007,17 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.context.append('')
 
     def depart_subtitle(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.subtitle) -> None
         self.body.append(self.context.pop())
 
     def visit_desc(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc) -> None
         self.body.append('\n\n\\begin{fulllineitems}\n')
         if self.table:
             self.table.has_problematic = True
 
     def depart_desc(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc) -> None
         self.body.append('\n\\end{fulllineitems}\n\n')
 
     def _visit_signature_line(self, node):
@@ -1033,7 +1034,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.body.append('}')
 
     def visit_desc_signature(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_signature) -> None
         if node.parent['objtype'] != 'describe' and node['ids']:
             hyper = self.hypertarget(node['ids'][0])
         else:
@@ -1045,71 +1046,71 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append('%\n\\pysigstartmultiline\n')
 
     def depart_desc_signature(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_signature) -> None
         if not node.get('is_multiline'):
             self._depart_signature_line(node)
         else:
             self.body.append('%\n\\pysigstopmultiline')
 
     def visit_desc_signature_line(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_signature_line) -> None
         self._visit_signature_line(node)
 
     def depart_desc_signature_line(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_signature_line) -> None
         self._depart_signature_line(node)
 
     def visit_desc_addname(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_addname) -> None
         self.body.append(r'\sphinxcode{\sphinxupquote{')
         self.literal_whitespace += 1
 
     def depart_desc_addname(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_addname) -> None
         self.body.append('}}')
         self.literal_whitespace -= 1
 
     def visit_desc_type(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_type) -> None
         pass
 
     def depart_desc_type(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_type) -> None
         pass
 
     def visit_desc_returns(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_returns) -> None
         self.body.append(r'{ $\rightarrow$ ')
 
     def depart_desc_returns(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_returns) -> None
         self.body.append(r'}')
 
     def visit_desc_name(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_name) -> None
         self.body.append(r'\sphinxbfcode{\sphinxupquote{')
         self.no_contractions += 1
         self.literal_whitespace += 1
 
     def depart_desc_name(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_name) -> None
         self.body.append('}}')
         self.literal_whitespace -= 1
         self.no_contractions -= 1
 
     def visit_desc_parameterlist(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_parameterlist) -> None
         # close name, open parameterlist
         self.body.append('}{')
         self.first_param = 1
 
     def depart_desc_parameterlist(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_parameterlist) -> None
         # close parameterlist, open return annotation
         self.body.append('}{')
 
     def visit_desc_parameter(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_parameter) -> None
         if not self.first_param:
             self.body.append(', ')
         else:
@@ -1118,46 +1119,46 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append(r'\emph{')
 
     def depart_desc_parameter(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_parameter) -> None
         if not node.hasattr('noemph'):
             self.body.append('}')
 
     def visit_desc_optional(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_optional) -> None
         self.body.append(r'\sphinxoptional{')
 
     def depart_desc_optional(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_optional) -> None
         self.body.append('}')
 
     def visit_desc_annotation(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_annotation) -> None
         self.body.append(r'\sphinxbfcode{\sphinxupquote{')
 
     def depart_desc_annotation(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_annotation) -> None
         self.body.append('}}')
 
     def visit_desc_content(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_content) -> None
         if node.children and not isinstance(node.children[0], nodes.paragraph):
             # avoid empty desc environment which causes a formatting bug
             self.body.append('~')
 
     def depart_desc_content(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.desc_content) -> None
         pass
 
     def visit_seealso(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.seealso) -> None
         self.body.append(u'\n\n\\sphinxstrong{%s:}\n\n' % admonitionlabels['seealso'])
 
     def depart_seealso(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.seealso) -> None
         self.body.append("\n\n")
 
     def visit_rubric(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.rubric) -> None
         if len(node.children) == 1 and node.children[0].astext() in \
            ('Footnotes', _('Footnotes')):
             raise nodes.SkipNode
@@ -1166,12 +1167,12 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.in_title = 1
 
     def depart_rubric(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.rubric) -> None
         self.in_title = 0
         self.body.append(self.context.pop())
 
     def visit_footnote(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.footnote) -> None
         self.in_footnote += 1
         if self.in_parsed_literal:
             self.body.append('\\begin{footnote}[%s]' % node[0].astext())
@@ -1180,7 +1181,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.body.append('\\sphinxAtStartFootnote\n')
 
     def depart_footnote(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.footnote) -> None
         if self.in_parsed_literal:
             self.body.append('\\end{footnote}')
         else:
@@ -1188,16 +1189,16 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.in_footnote -= 1
 
     def visit_label(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.label) -> None
         raise nodes.SkipNode
 
     def visit_tabular_col_spec(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.tabular_col_spec) -> None
         self.next_table_colspec = node['spec']
         raise nodes.SkipNode
 
     def visit_table(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.table) -> None
         if self.table:
             raise UnsupportedError(
                 '%s:%s: nested tables are not yet implemented.' %
@@ -1211,7 +1212,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.next_table_colspec = None
 
     def depart_table(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.table) -> None
         labels = self.hypertarget_to(node)
         table_type = self.table.get_table_type()
         table = self.render(table_type + '.tex_t',
@@ -1223,7 +1224,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.table = None
 
     def visit_colspec(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.colspec) -> None
         self.table.colcount += 1
         if 'colwidth' in node:
             self.table.colwidths.append(node['colwidth'])
@@ -1231,37 +1232,37 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.table.stubs.append(self.table.colcount - 1)
 
     def depart_colspec(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.colspec) -> None
         pass
 
     def visit_tgroup(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.tgroup) -> None
         pass
 
     def depart_tgroup(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.tgroup) -> None
         pass
 
     def visit_thead(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.thead) -> None
         # Redirect head output until header is finished.
         self.pushbody(self.table.header)
 
     def depart_thead(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.thead) -> None
         self.popbody()
 
     def visit_tbody(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.tbody) -> None
         # Redirect body output until table is finished.
         self.pushbody(self.table.body)
 
     def depart_tbody(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.tbody) -> None
         self.popbody()
 
     def visit_row(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.row) -> None
         self.table.col = 0
 
         # fill columns if the row starts with the bottom of multirow cell
@@ -1282,7 +1283,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
                                      (cell.width, cell.cell_id))
 
     def depart_row(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.row) -> None
         self.body.append('\\\\\n')
         cells = [self.table.cell(self.table.row, i) for i in range(self.table.colcount)]
         underlined = [cell.row + cell.height == self.table.row + 1 for cell in cells]
@@ -1300,7 +1301,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.table.row += 1
 
     def visit_entry(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.entry) -> None
         if self.table.col > 0:
             self.body.append('&')
         self.table.add_cell(node.get('morerows', 0) + 1, node.get('morecols', 0) + 1)
@@ -1338,7 +1339,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.context.append(context)
 
     def depart_entry(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.entry) -> None
         if self.needs_linetrimming:
             self.needs_linetrimming = 0
             body = self.popbody()
@@ -1372,7 +1373,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
                                      (nextcell.width, nextcell.cell_id))
 
     def visit_acks(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.acks) -> None
         # this is a list in the source, but should be rendered as a
         # comma-separated list here
         self.body.append('\n\n')
@@ -1382,19 +1383,19 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_bullet_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.bullet_list) -> None
         if not self.compact_list:
             self.body.append('\\begin{itemize}\n')
         if self.table:
             self.table.has_problematic = True
 
     def depart_bullet_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.bullet_list) -> None
         if not self.compact_list:
             self.body.append('\\end{itemize}\n')
 
     def visit_enumerated_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.enumerated_list) -> None
         def get_enumtype(node):
             # type: (nodes.Node) -> unicode
             enumtype = node.get('enumtype', 'arabic')
@@ -1431,39 +1432,39 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.table.has_problematic = True
 
     def depart_enumerated_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.enumerated_list) -> None
         self.body.append('\\end{enumerate}\n')
 
     def visit_list_item(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.list_item) -> None
         # Append "{}" in case the next character is "[", which would break
         # LaTeX's list environment (no numbering and the "[" is not printed).
         self.body.append(r'\item {} ')
 
     def depart_list_item(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.list_item) -> None
         self.body.append('\n')
 
     def visit_definition_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.definition_list) -> None
         self.body.append('\\begin{description}\n')
         if self.table:
             self.table.has_problematic = True
 
     def depart_definition_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.definition_list) -> None
         self.body.append('\\end{description}\n')
 
     def visit_definition_list_item(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.definition_list_item) -> None
         pass
 
     def depart_definition_list_item(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.definition_list_item) -> None
         pass
 
     def visit_term(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.term) -> None
         self.in_term += 1
         ctx = ''  # type: unicode
         if node.get('ids'):
@@ -1475,42 +1476,42 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.context.append(ctx)
 
     def depart_term(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.term) -> None
         self.body.append(self.context.pop())
         self.in_term -= 1
 
     def visit_classifier(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.classifier) -> None
         self.body.append('{[}')
 
     def depart_classifier(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.classifier) -> None
         self.body.append('{]}')
 
     def visit_definition(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.definition) -> None
         pass
 
     def depart_definition(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.definition) -> None
         self.body.append('\n')
 
     def visit_field_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.field_list) -> None
         self.body.append('\\begin{quote}\\begin{description}\n')
         if self.table:
             self.table.has_problematic = True
 
     def depart_field_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.field_list) -> None
         self.body.append('\\end{description}\\end{quote}\n')
 
     def visit_field(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.field) -> None
         pass
 
     def depart_field(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.field) -> None
         pass
 
     visit_field_name = visit_term
@@ -1520,7 +1521,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
     depart_field_body = depart_definition
 
     def visit_paragraph(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.paragraph) -> None
         index = node.parent.index(node)
         if (index > 0 and isinstance(node.parent, nodes.compound) and
                 not isinstance(node.parent[index - 1], nodes.paragraph) and
@@ -1535,21 +1536,21 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append('\n')
 
     def depart_paragraph(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.paragraph) -> None
         self.body.append('\n')
 
     def visit_centered(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.centered) -> None
         self.body.append('\n\\begin{center}')
         if self.table:
             self.table.has_problematic = True
 
     def depart_centered(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.centered) -> None
         self.body.append('\n\\end{center}')
 
     def visit_hlist(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.hlist) -> None
         # for now, we don't support a more compact list format
         # don't add individual itemize environments, but one for all columns
         self.compact_list += 1
@@ -1559,16 +1560,16 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.table.has_problematic = True
 
     def depart_hlist(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.hlist) -> None
         self.compact_list -= 1
         self.body.append('\\end{itemize}\n')
 
     def visit_hlistcol(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.hlistcol) -> None
         pass
 
     def depart_hlistcol(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.hlistcol) -> None
         pass
 
     def latex_image_length(self, width_str):
@@ -1585,7 +1586,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         return isinstance(node.parent, nodes.TextElement)
 
     def visit_image(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.image) -> None
         attrs = node.attributes
         pre = []    # type: List[unicode]
                     # in reverse order
@@ -1662,11 +1663,11 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.body.extend(post)
 
     def depart_image(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.image) -> None
         pass
 
     def visit_figure(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.figure) -> None
         if self.table:
             # TODO: support align option
             if 'width' in node:
@@ -1699,11 +1700,11 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.context.append('\\end{figure}\n')
 
     def depart_figure(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.figure) -> None
         self.body.append(self.context.pop())
 
     def visit_caption(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.caption) -> None
         self.in_caption += 1
         if isinstance(node.parent, captioned_literal_block):
             self.body.append('\\sphinxSetupCaptionForVerbatim{')
@@ -1715,7 +1716,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append('\\caption{')
 
     def depart_caption(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.caption) -> None
         self.body.append('}')
         if isinstance(node.parent, nodes.figure):
             labels = self.hypertarget_to(node.parent)
@@ -1723,25 +1724,25 @@ class LaTeXTranslator(nodes.NodeVisitor):
         self.in_caption -= 1
 
     def visit_legend(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.legend) -> None
         self.body.append('\n\\begin{sphinxlegend}')
 
     def depart_legend(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.legend) -> None
         self.body.append('\\end{sphinxlegend}\n')
 
     def visit_admonition(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.admonition) -> None
         self.body.append('\n\\begin{sphinxadmonition}{note}')
 
     def depart_admonition(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.admonition) -> None
         self.body.append('\\end{sphinxadmonition}\n')
 
     def _make_visit_admonition(name):
         # type: (unicode) -> Callable[[LaTeXTranslator, nodes.Node], None]
         def visit_admonition(self, node):
-            # type: (nodes.Node) -> None
+            # type: (nodes.admonition) -> None
             self.body.append(u'\n\\begin{sphinxadmonition}{%s}{%s:}' %
                              (name, admonitionlabels[name]))
         return visit_admonition
@@ -1770,15 +1771,15 @@ class LaTeXTranslator(nodes.NodeVisitor):
     depart_warning = _depart_named_admonition
 
     def visit_versionmodified(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.versionmodified) -> None
         pass
 
     def depart_versionmodified(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.versionmodified) -> None
         pass
 
     def visit_target(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.target) -> None
         def add_target(id):
             # type: (unicode) -> None
             # indexing uses standard LaTeX index markup, so the targets
@@ -1819,20 +1820,20 @@ class LaTeXTranslator(nodes.NodeVisitor):
             add_target(id)
 
     def depart_target(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.target) -> None
         pass
 
     def visit_attribution(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.attribution) -> None
         self.body.append('\n\\begin{flushright}\n')
         self.body.append('---')
 
     def depart_attribution(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.attribution) -> None
         self.body.append('\n\\end{flushright}\n')
 
     def visit_index(self, node, scre = None):
-        # type: (nodes.Node, None) -> None
+        # type: (addnodes.index, Pattern) -> None
         def escape(value):
             value = self.encode(value)
             value = value.replace(r'\{', r'\sphinxleftcurlybrace{}')
@@ -1902,7 +1903,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_raw(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.raw) -> None
         if not self.is_inline(node):
             self.body.append('\n')
         if 'latex' in node.get('format', '').split():
@@ -1912,7 +1913,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.reference) -> None
         if not self.in_title:
             for id in node.get('ids'):
                 anchor = not self.in_caption
@@ -1967,11 +1968,11 @@ class LaTeXTranslator(nodes.NodeVisitor):
                 self.context.append('}')
 
     def depart_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.reference) -> None
         self.body.append(self.context.pop())
 
     def visit_number_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.number_reference) -> None
         if node.get('refid'):
             id = self.curfilestack[-1] + ':' + node['refid']
         else:
@@ -1993,59 +1994,59 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_download_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.download_reference) -> None
         pass
 
     def depart_download_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.download_reference) -> None
         pass
 
     def visit_pending_xref(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.pending_xref) -> None
         pass
 
     def depart_pending_xref(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.pending_xref) -> None
         pass
 
     def visit_emphasis(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.emphasis) -> None
         self.body.append(r'\sphinxstyleemphasis{')
 
     def depart_emphasis(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.emphasis) -> None
         self.body.append('}')
 
     def visit_literal_emphasis(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.literal_emphasis) -> None
         self.body.append(r'\sphinxstyleliteralemphasis{\sphinxupquote{')
         self.no_contractions += 1
 
     def depart_literal_emphasis(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.literal_emphasis) -> None
         self.body.append('}}')
         self.no_contractions -= 1
 
     def visit_strong(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.strong) -> None
         self.body.append(r'\sphinxstylestrong{')
 
     def depart_strong(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.strong) -> None
         self.body.append('}')
 
     def visit_literal_strong(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.literal_strong) -> None
         self.body.append(r'\sphinxstyleliteralstrong{\sphinxupquote{')
         self.no_contractions += 1
 
     def depart_literal_strong(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.literal_strong) -> None
         self.body.append('}}')
         self.no_contractions -= 1
 
     def visit_abbreviation(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.abbreviation) -> None
         abbr = node.astext()
         self.body.append(r'\sphinxstyleabbreviation{')
         # spell out the explanation once
@@ -2056,27 +2057,27 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.context.append('}')
 
     def depart_abbreviation(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.abbreviation) -> None
         self.body.append(self.context.pop())
 
     def visit_manpage(self, node):
-        # type: (nodes.Node) -> Any
+        # type: (addnodes.manpage) -> None
         return self.visit_literal_emphasis(node)
 
     def depart_manpage(self, node):
-        # type: (nodes.Node) -> Any
+        # type: (addnodes.manpage) -> None
         return self.depart_literal_emphasis(node)
 
     def visit_title_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.title_reference) -> None
         self.body.append(r'\sphinxtitleref{')
 
     def depart_title_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.title_reference) -> None
         self.body.append('}')
 
     def visit_thebibliography(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.thebibliography) -> None
         longest_label = max((subnode[0].astext() for subnode in node), key=len)
         if len(longest_label) > MAX_CITATION_LABEL_LENGTH:
             # adjust max width of citation labels not to break the layout
@@ -2086,21 +2087,21 @@ class LaTeXTranslator(nodes.NodeVisitor):
                          self.encode(longest_label))
 
     def depart_thebibliography(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.thebibliography) -> None
         self.body.append(u'\\end{sphinxthebibliography}\n')
 
     def visit_citation(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.citation) -> None
         label = node[0].astext()
         self.body.append(u'\\bibitem[%s]{%s:%s}' %
                          (self.encode(label), node['docname'], node['ids'][0]))
 
     def depart_citation(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.citation) -> None
         pass
 
     def visit_citation_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.citation_reference) -> None
         if self.in_title:
             pass
         else:
@@ -2108,11 +2109,11 @@ class LaTeXTranslator(nodes.NodeVisitor):
             raise nodes.SkipNode
 
     def depart_citation_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.citation_reference) -> None
         pass
 
     def visit_literal(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.literal) -> None
         self.no_contractions += 1
         if self.in_title:
             self.body.append(r'\sphinxstyleliteralintitle{\sphinxupquote{')
@@ -2120,43 +2121,43 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append(r'\sphinxcode{\sphinxupquote{')
 
     def depart_literal(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.literal) -> None
         self.no_contractions -= 1
         self.body.append('}}')
 
     def visit_footnote_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.footnote_reference) -> None
         raise nodes.SkipNode
 
     def visit_footnotemark(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.footnotemark) -> None
         self.body.append('\\sphinxfootnotemark[')
 
     def depart_footnotemark(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.footnotemark) -> None
         self.body.append(']')
 
     def visit_footnotetext(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.footnotetext) -> None
         number = node[0].astext()
         self.body.append('%%\n\\begin{footnotetext}[%s]'
                          '\\sphinxAtStartFootnote\n' % number)
 
     def depart_footnotetext(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.footnotetext) -> None
         # the \ignorespaces in particular for after table header use
         self.body.append('%\n\\end{footnotetext}\\ignorespaces ')
 
     def visit_captioned_literal_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.captioned_literal_block) -> None
         pass
 
     def depart_captioned_literal_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.captioned_literal_block) -> None
         pass
 
     def visit_literal_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.literal_block) -> None
         if node.rawsource != node.astext():
             # most probably a parsed-literal block -- don't highlight
             self.in_parsed_literal += 1
@@ -2211,22 +2212,22 @@ class LaTeXTranslator(nodes.NodeVisitor):
             raise nodes.SkipNode
 
     def depart_literal_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.literal_block) -> None
         self.body.append('\n\\end{sphinxalltt}\n')
         self.in_parsed_literal -= 1
     visit_doctest_block = visit_literal_block
     depart_doctest_block = depart_literal_block
 
     def visit_line(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.line) -> None
         self.body.append('\\item[] ')
 
     def depart_line(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.line) -> None
         self.body.append('\n')
 
     def visit_line_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.line_block) -> None
         if isinstance(node.parent, nodes.line_block):
             self.body.append('\\item[]\n'
                              '\\begin{DUlineblock}{\\DUlineblockindent}\n')
@@ -2236,11 +2237,11 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.table.has_problematic = True
 
     def depart_line_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.line_block) -> None
         self.body.append('\\end{DUlineblock}\n')
 
     def visit_block_quote(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.block_quote) -> None
         # If the block quote contains a single object and that object
         # is a list, then generate a list not a block quote.
         # This lets us indent lists.
@@ -2256,7 +2257,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
                 self.table.has_problematic = True
 
     def depart_block_quote(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.block_quote) -> None
         done = 0
         if len(node.children) == 1:
             child = node.children[0]
@@ -2269,56 +2270,56 @@ class LaTeXTranslator(nodes.NodeVisitor):
     # option node handling copied from docutils' latex writer
 
     def visit_option(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option) -> None
         if self.context[-1]:
             # this is not the first option
             self.body.append(', ')
 
     def depart_option(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option) -> None
         # flag that the first option is done.
         self.context[-1] += 1
 
     def visit_option_argument(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_argument) -> None
         """The delimiter betweeen an option and its argument."""
         self.body.append(node.get('delimiter', ' '))
 
     def depart_option_argument(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_argument) -> None
         pass
 
     def visit_option_group(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_group) -> None
         self.body.append('\\item [')
         # flag for first option
         self.context.append(0)
 
     def depart_option_group(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_group) -> None
         self.context.pop()  # the flag
         self.body.append('] ')
 
     def visit_option_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_list) -> None
         self.body.append('\\begin{optionlist}{3cm}\n')
         if self.table:
             self.table.has_problematic = True
 
     def depart_option_list(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_list) -> None
         self.body.append('\\end{optionlist}\n')
 
     def visit_option_list_item(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_list_item) -> None
         pass
 
     def depart_option_list_item(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_list_item) -> None
         pass
 
     def visit_option_string(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.option_string) -> None
         ostring = node.astext()
         self.no_contractions += 1
         self.body.append(self.encode(ostring))
@@ -2326,31 +2327,31 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_description(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.description) -> None
         self.body.append(' ')
 
     def depart_description(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.description) -> None
         pass
 
     def visit_superscript(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.superscript) -> None
         self.body.append('$^{\\text{')
 
     def depart_superscript(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.superscript) -> None
         self.body.append('}}$')
 
     def visit_subscript(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.subscript) -> None
         self.body.append('$_{\\text{')
 
     def depart_subscript(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.subscript) -> None
         self.body.append('}}$')
 
     def visit_inline(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.inline) -> None
         classes = node.get('classes', [])
         if classes in [['menuselection']]:
             self.body.append(r'\sphinxmenuselection{')
@@ -2368,53 +2369,53 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.context.append('')
 
     def depart_inline(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.inline) -> None
         self.body.append(self.context.pop())
 
     def visit_generated(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.generated) -> None
         pass
 
     def depart_generated(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.generated) -> None
         pass
 
     def visit_compound(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.compound) -> None
         pass
 
     def depart_compound(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.compound) -> None
         pass
 
     def visit_container(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.container) -> None
         pass
 
     def depart_container(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.container) -> None
         pass
 
     def visit_decoration(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.decoration) -> None
         pass
 
     def depart_decoration(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.decoration) -> None
         pass
 
     # docutils-generated elements that we don't support
 
     def visit_header(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.header) -> None
         raise nodes.SkipNode
 
     def visit_footer(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.footer) -> None
         raise nodes.SkipNode
 
     def visit_docinfo(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.docinfo) -> None
         raise nodes.SkipNode
 
     # text handling
@@ -2437,33 +2438,33 @@ class LaTeXTranslator(nodes.NodeVisitor):
         return self.encode(text).replace('\\textasciitilde{}', '~')
 
     def visit_Text(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.Text) -> None
         text = self.encode(node.astext())
         self.body.append(text)
 
     def depart_Text(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.Text) -> None
         pass
 
     def visit_comment(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.comment) -> None
         raise nodes.SkipNode
 
     def visit_meta(self, node):
-        # type: (nodes.Node) -> None
+        # type: (addnodes.meta) -> None
         # only valid for HTML
         raise nodes.SkipNode
 
     def visit_system_message(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.system_message) -> None
         pass
 
     def depart_system_message(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.system_message) -> None
         self.body.append('\n')
 
     def visit_math(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.math) -> None
         if self.in_title:
             self.body.append(r'\protect\(%s\protect\)' % node.astext())
         else:
@@ -2471,7 +2472,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_math_block(self, node):
-        # type: (nodes.Node) -> None
+        # type: (nodes.math_block) -> None
         if node.get('label'):
             label = "equation:%s:%s" % (node['docname'], node['label'])
         else:
@@ -2488,7 +2489,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
         raise nodes.SkipNode
 
     def visit_math_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.math_reference) -> None
         label = "equation:%s:%s" % (node['docname'], node['target'])
         eqref_format = self.builder.config.math_eqref_format
         if eqref_format:
@@ -2503,7 +2504,7 @@ class LaTeXTranslator(nodes.NodeVisitor):
             self.body.append(r'\eqref{%s}' % label)
 
     def depart_math_reference(self, node):
-        # type: (nodes.Node) -> None
+        # type: (latexnodes.math_reference) -> None
         pass
 
     def unknown_visit(self, node):