Add some typing

Add some typing to different methods to converge,
over time, to a more strong typed code.

Author: boriel

api/check.py

@@ -76,7 +76,7 @@ def check_is_declared_explicit(lineno, id_, classname='variable'):
     return entry is not None  # True if declared
 
 
-def check_type_is_explicit(lineno, id_, type_):
+def check_type_is_explicit(lineno: int, id_: str, type_):
     from symbols.type_ import SymbolTYPE
     assert isinstance(type_, SymbolTYPE)
     if type_.implicit:

api/errmsg.py

@@ -178,7 +178,7 @@ def syntax_error_is_a_sub_not_a_func(lineno, name):
 # ----------------------------------------
 # Syntax error: strict mode: missing type declaration
 # ----------------------------------------
-def syntax_error_undeclared_type(lineno, id_):
+def syntax_error_undeclared_type(lineno: int, id_: str):
     syntax_error(lineno, "strict mode: missing type declaration for '%s'" % id_)
 
 

api/symboltable.py

@@ -144,7 +144,7 @@ def current_scope(self):
     def global_scope(self):
         return 0
 
-    def get_entry(self, id_, scope=None):
+    def get_entry(self, id_: str, scope=None):
         """ Returns the ID entry stored in self.table, starting
         by the first one. Returns None if not found.
         If scope is not None, only the given scope is searched.
@@ -162,7 +162,7 @@ def get_entry(self, id_, scope=None):
 
         return None  # Not found
 
-    def declare(self, id_, lineno, entry):
+    def declare(self, id_: str, lineno: int, entry):
         """ Check there is no 'id' already declared in the current scope, and
             creates and returns it. Otherwise, returns None,
             and the caller function raises the syntax/semantic error.
@@ -204,7 +204,7 @@ def declare(self, id_, lineno, entry):
     # -------------------------------------------------------------------------
     # Symbol Table Checks
     # -------------------------------------------------------------------------
-    def check_is_declared(self, id_, lineno, classname='identifier',
+    def check_is_declared(self, id_: str, lineno: int, classname='identifier',
                           scope=None, show_error=True):
         """ Checks if the given id is already defined in any scope
             or raises a Syntax Error.
@@ -222,7 +222,7 @@ def check_is_declared(self, id_, lineno, classname='identifier',
             return False
         return True
 
-    def check_is_undeclared(self, id_, lineno, classname='identifier',
+    def check_is_undeclared(self, id_: str, lineno: int, classname='identifier',
                             scope=None, show_error=False):
         """ The reverse of the above.
 
@@ -243,7 +243,7 @@ def check_is_undeclared(self, id_, lineno, classname='identifier',
                           self.table[scope][id_].lineno))
         return False
 
-    def check_class(self, id_, class_, lineno, scope=None, show_error=True):
+    def check_class(self, id_: str, class_, lineno: int, scope=None, show_error=True):
         """ Check the id is either undefined or defined with
         the given class.
 
@@ -345,7 +345,7 @@ def entry_size(entry):
         global_.LOOPS = global_.META_LOOPS.pop()
         return offset
 
-    def move_to_global_scope(self, id_):
+    def move_to_global_scope(self, id_: str):
         """ If the given id is in the current scope, and there is more than
         1 scope, move the current id to the global scope and make it global.
         Labels need this.
@@ -362,7 +362,7 @@ def move_to_global_scope(self, id_):
             del self.table[self.current_scope][id_]  # Removes it from the current scope
             __DEBUG__("'{}' entry moved to global scope".format(id_))
 
-    def make_static(self, id_):
+    def make_static(self, id_: str):
         """ The given ID in the current scope is changed to 'global', but the
         variable remains in the current scope, if it's a 'global private'
         variable: A variable private to a function scope, but whose contents
@@ -388,7 +388,7 @@ def update_aliases(entry):
         for symbol in entry.aliased_by:
             symbol.alias = entry
 
-    def access_id(self, id_, lineno, scope=None, default_type=None, default_class=CLASS.unknown):
+    def access_id(self, id_: str, lineno: int, scope=None, default_type=None, default_class=CLASS.unknown):
         """ Access a symbol by its identifier and checks if it exists.
         If not, it's supposed to be an implicit declared variable.
 
@@ -420,7 +420,7 @@ def access_id(self, id_, lineno, scope=None, default_type=None, default_class=CL
 
         return result
 
-    def access_var(self, id_, lineno, scope=None, default_type=None):
+    def access_var(self, id_: str, lineno: int, scope=None, default_type=None):
         """
         Since ZX BASIC allows access to undeclared variables, we must allow
         them, and *implicitly* declare them if they are not declared already.
@@ -444,7 +444,7 @@ def access_var(self, id_, lineno, scope=None, default_type=None):
 
         return result
 
-    def access_array(self, id_, lineno, scope=None, default_type=None):
+    def access_array(self, id_: str, lineno: int, scope=None, default_type=None):
         """
         Called whenever an accessed variable is expected to be an array.
         ZX BASIC requires arrays to be declared before usage, so they're
@@ -460,7 +460,7 @@ def access_array(self, id_, lineno, scope=None, default_type=None):
 
         return self.access_id(id_, lineno, scope=scope, default_type=default_type)
 
-    def access_func(self, id_, lineno, scope=None, default_type=None):
+    def access_func(self, id_: str, lineno: int, scope=None, default_type=None):
         """
         Since ZX BASIC allows access to undeclared functions, we must allow
         and *implicitly* declare them if they are not declared already.
@@ -484,7 +484,7 @@ def access_func(self, id_, lineno, scope=None, default_type=None):
 
         return result
 
-    def access_call(self, id_, lineno, scope=None, type_=None):
+    def access_call(self, id_: str, lineno: int, scope=None, type_=None):
         """ Creates a func/array/string call. Checks if id is callable or not.
         An identifier is "callable" if it can be followed by a list of para-
         meters.
@@ -613,7 +613,7 @@ def declare_type(self, type_):
         entry = self.declare(type_.name, type_.lineno, type_)
         return entry
 
-    def declare_const(self, id_, lineno, type_, default_value):
+    def declare_const(self, id_: str, lineno: int, type_, default_value):
         """ Similar to the above. But declares a Constant.
         """
         if not self.check_is_undeclared(id_, lineno, scope=self.current_scope, show_error=False):
@@ -634,7 +634,7 @@ def declare_const(self, id_, lineno, type_, default_value):
         entry.class_ = CLASS.const
         return entry
 
-    def declare_label(self, id_, lineno):
+    def declare_label(self, id_: str, lineno: int):
         """ Declares a label (line numbers are also labels).
             Unlike variables, labels are always global.
         """
@@ -685,7 +685,7 @@ def declare_label(self, id_, lineno):
         entry.type_ = self.basic_types[global_.PTR_TYPE]
         return entry
 
-    def declare_param(self, id_, lineno, type_=None, is_array=False):
+    def declare_param(self, id_: str, lineno: int, type_=None, is_array=False):
         """ Declares a parameter
         Check if entry.declared is False. Otherwise raises an error.
         """
@@ -708,7 +708,7 @@ def declare_param(self, id_, lineno, type_=None, is_array=False):
             warning_implicit_type(lineno, id_, type_)
         return entry
 
-    def declare_array(self, id_, lineno, type_, bounds, default_value=None, addr=None):
+    def declare_array(self, id_: str, lineno: int, type_, bounds, default_value=None, addr=None):
         """ Declares an array in the symbol table (VARARRAY). Error if already
         exists.
         The optional parameter addr specifies if the array elements must be placed at an specific
@@ -768,7 +768,7 @@ def declare_array(self, id_, lineno, type_, bounds, default_value=None, addr=Non
                                                                    self.current_scope))
         return entry
 
-    def declare_func(self, id_, lineno, type_=None):
+    def declare_func(self, id_: str, lineno: int, type_=None):
         """ Declares a function in the current scope.
         Checks whether the id exist or not (error if exists).
         And creates the entry at the symbol table.