Declare instance variable types at class level

lark/grammar.py

@@ -8,10 +8,11 @@ from typing import Optional, Tuple
 class Symbol(Serialize):
     __slots__ = ('name',)
 
+    name: str
     is_term: bool = NotImplemented
 
-    def __init__(self, name):
-        self.name: str = name
+    def __init__(self, name: str) -> None:
+        self.name = name
 
     def __eq__(self, other):
         assert isinstance(other, Symbol), other
@@ -52,12 +53,18 @@ class NonTerminal(Symbol):
 class RuleOptions(Serialize):
     __serialize_fields__ = 'keep_all_tokens', 'expand1', 'priority', 'template_source', 'empty_indices'
 
-    def __init__(self, keep_all_tokens=False, expand1=False, priority=None, template_source=None, empty_indices=()):
-        self.keep_all_tokens: bool = keep_all_tokens
-        self.expand1: bool = expand1
-        self.priority: int = priority
-        self.template_source: Optional[str] = template_source
-        self.empty_indices: Tuple[bool, ...] = empty_indices
+    keep_all_tokens: bool
+    expand1: bool
+    priority: Optional[int]
+    template_source: Optional[str]
+    empty_indices: Tuple[bool, ...]
+
+    def __init__(self, keep_all_tokens: bool=False, expand1: bool=False, priority: Optional[int]=None, template_source: Optional[str]=None, empty_indices: Tuple[bool, ...]=()) -> None:
+        self.keep_all_tokens = keep_all_tokens
+        self.expand1 = expand1
+        self.priority = priority
+        self.template_source = template_source
+        self.empty_indices = empty_indices
 
     def __repr__(self):
         return 'RuleOptions(%r, %r, %r, %r)' % (

lark/indenter.py

@@ -13,9 +13,13 @@ class DedentError(LarkError):
     pass
 
 class Indenter(PostLex, ABC):
+
+    paren_level: Optional[int]
+    indent_level: Optional[List[int]]
+
     def __init__(self) -> None:
-        self.paren_level: Optional[int] = None
-        self.indent_level: Optional[List[int]] = None
+        self.paren_level = None
+        self.indent_level = None
         assert self.tab_len > 0
 
     def handle_NL(self, token: Token) -> Iterator[Token]:

lark/load_grammar.py

@@ -552,10 +552,15 @@ def nr_deepcopy_tree(t):
 
 
 class Grammar:
-    def __init__(self, rule_defs, term_defs, ignore):
-        self.term_defs: List[Tuple[str, Tuple[Tree, int]]] = term_defs
-        self.rule_defs: List[Tuple[str, Tuple[str, ...], Tree, RuleOptions]] = rule_defs
-        self.ignore: List[str] = ignore
+
+    term_defs: List[Tuple[str, Tuple[Tree, int]]]
+    rule_defs: List[Tuple[str, Tuple[str, ...], Tree, RuleOptions]]
+    ignore: List[str]
+
+    def __init__(self, rule_defs: List[Tuple[str, Tuple[str, ...], Tree, RuleOptions]], term_defs: List[Tuple[str, Tuple[Tree, int]]], ignore: List[str]) -> None:
+        self.term_defs = term_defs
+        self.rule_defs = rule_defs
+        self.ignore = ignore
 
     def compile(self, start, terminals_to_keep):
         # We change the trees in-place (to support huge grammars)
@@ -928,10 +933,15 @@ def _mangle_exp(exp, mangle):
 
 
 class GrammarBuilder:
-    def __init__(self, global_keep_all_tokens: bool=False, import_paths: List[Union[str, Callable]]=None, used_files: Dict[str, str]=None) -> None:
-        self.global_keep_all_tokens: bool = global_keep_all_tokens
-        self.import_paths: List[Union[str, Callable]] = import_paths or []
-        self.used_files: Dict[str, str] = used_files or {}
+
+    global_keep_all_tokens: bool
+    import_paths: List[Union[str, Callable]]
+    used_files: Dict[str, str]
+
+    def __init__(self, global_keep_all_tokens: bool=False, import_paths: Optional[List[Union[str, Callable]]]=None, used_files: Optional[Dict[str, str]]=None) -> None:
+        self.global_keep_all_tokens = global_keep_all_tokens
+        self.import_paths = import_paths or []
+        self.used_files = used_files or {}
 
         self._definitions = {}
         self._ignore_names = []
@@ -1072,7 +1082,7 @@ class GrammarBuilder:
         return name, exp, params, opts
 
 
-    def load_grammar(self, grammar_text: str, grammar_name: str="<?>", mangle: Callable[[str], str]=None) -> None:
+    def load_grammar(self, grammar_text: str, grammar_name: str="<?>", mangle: Optional[Callable[[str], str]]=None) -> None:
         tree = _parse_grammar(grammar_text, grammar_name)
 
         imports = {}
@@ -1135,7 +1145,7 @@ class GrammarBuilder:
         self._definitions = {k: v for k, v in self._definitions.items() if k in _used}
 
 
-    def do_import(self, dotted_path: Tuple[str, ...], base_path: Optional[str], aliases: Dict[str, str], base_mangle: Callable[[str], str]=None) -> None:
+    def do_import(self, dotted_path: Tuple[str, ...], base_path: Optional[str], aliases: Dict[str, str], base_mangle: Optional[Callable[[str], str]]=None) -> None:
         assert dotted_path
         mangle = _get_mangle('__'.join(dotted_path), aliases, base_mangle)
         grammar_path = os.path.join(*dotted_path) + EXT

lark/reconstruct.py

@@ -1,6 +1,6 @@
 """Reconstruct text from a tree, based on Lark grammar"""
 
-from typing import List, Dict, Union, Callable, Iterable
+from typing import List, Dict, Union, Callable, Iterable, Optional
 import unicodedata
 
 from .lark import Lark
@@ -23,6 +23,9 @@ def is_iter_empty(i):
 class WriteTokensTransformer(Transformer_InPlace):
     "Inserts discarded tokens into their correct place, according to the rules of grammar"
 
+    tokens: Dict[str, TerminalDef]
+    term_subs: Dict[str, Callable[[Symbol], str]]
+
     def __init__(self, tokens: Dict[str, TerminalDef], term_subs: Dict[str, Callable[[Symbol], str]]) -> None:
         self.tokens = tokens
         self.term_subs = term_subs
@@ -72,7 +75,9 @@ class Reconstructor(TreeMatcher):
         term_subs: a dictionary of [Terminal name as str] to [output text as str]
     """
 
-    def __init__(self, parser: Lark, term_subs: Dict[str, Callable[[Symbol], str]]=None) -> None:
+    write_tokens: WriteTokensTransformer
+
+    def __init__(self, parser: Lark, term_subs: Optional[Dict[str, Callable[[Symbol], str]]]=None) -> None:
         TreeMatcher.__init__(self, parser)
 
         self.write_tokens = WriteTokensTransformer({t.name:t for t in self.tokens}, term_subs or {})
@@ -89,7 +94,7 @@ class Reconstructor(TreeMatcher):
             else:
                 yield item
 
-    def reconstruct(self, tree: Tree, postproc: Callable[[Iterable[str]], Iterable[str]]=None, insert_spaces: bool=True) -> str:
+    def reconstruct(self, tree: Tree, postproc: Optional[Callable[[Iterable[str]], Iterable[str]]]=None, insert_spaces: bool=True) -> str:
         x = self._reconstruct(tree)
         if postproc:
             x = postproc(x)

lark/visitors.py

@@ -8,7 +8,7 @@ from .lexer import Token
 
 ###{standalone
 from inspect import getmembers, getmro
-from typing import TypeVar, Tuple, List, Callable, Generic, Type, Union
+from typing import TypeVar, Tuple, List, Callable, Generic, Type, Union, Optional
 
 _T = TypeVar('_T')
 _R = TypeVar('_R')
@@ -156,8 +156,11 @@ class Transformer(_Decoratable, ABC, Generic[_T]):
 
 
 class TransformerChain(Generic[_T]):
-    def __init__(self, *transformers):
-        self.transformers: Tuple[Transformer[_T], ...] = transformers
+
+    transformers: Tuple[Transformer[_T], ...]
+
+    def __init__(self, *transformers: Transformer[_T]) -> None:
+        self.transformers = transformers
 
     def transform(self, tree: Tree) -> _T:
         for t in self.transformers:
@@ -387,7 +390,7 @@ def _vargs_tree(f, data, children, meta):
     return f(Tree(data, children, meta))
 
 
-def v_args(inline: bool=False, meta: bool=False, tree: bool=False, wrapper: Callable[[_DECORATED], _DECORATED]=None) -> Callable[[_DECORATED], _DECORATED]:
+def v_args(inline: bool=False, meta: bool=False, tree: bool=False, wrapper: Optional[Callable]=None) -> Callable[[_DECORATED], _DECORATED]:
     """A convenience decorator factory for modifying the behavior of user-supplied visitor methods.
 
     By default, callback methods of transformers/visitors accept one argument - a list of the node's children.