Merge pull request #551 from boriel/refact/remove_kind_constants

Refact/remove kind constants

Author: boriel

src/api/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# vim: ts=4:et:sw=4:
-
-# ----------------------------------------------------------------------
-# Copyleft (K), Jose M. Rodriguez-Rosa (a.k.a. Boriel)
-#
-# This program is Free Software and is released under the terms of
-#                    the GNU General License
-# ----------------------------------------------------------------------
-
-from src.api import debug  # noqa
-from src.api import errors  # noqa
-from src.api import errmsg  # noqa
-from src.api import utils  # noqa
-from src.api import symboltable  # noqa

src/api/check.py

@@ -11,34 +11,34 @@
 
 from typing import Union
 
-import src.api.errmsg as errmsg
+from src.api import config
+from src.api import global_
+from src.api import errmsg
+
 import src.symbols as symbols
 
 from src.symbols.type_ import Type
-
-from .constants import CLASS
-from .constants import SCOPE
-
-from . import config
-from . import global_
-
-__all__ = ['check_type',
-           'check_is_declared_explicit',
-           'check_and_make_label',
-           'check_type_is_explicit',
-           'check_call_arguments',
-           'check_pending_calls',
-           'check_pending_labels',
-           'is_number',
-           'is_const',
-           'is_static',
-           'is_string',
-           'is_numeric',
-           'is_dynamic',
-           'is_null',
-           'is_unsigned',
-           'common_type'
-           ]
+from src.api.constants import CLASS, SCOPE
+
+
+__all__ = [
+    'check_type',
+    'check_is_declared_explicit',
+    'check_and_make_label',
+    'check_type_is_explicit',
+    'check_call_arguments',
+    'check_pending_calls',
+    'check_pending_labels',
+    'is_number',
+    'is_const',
+    'is_static',
+    'is_string',
+    'is_numeric',
+    'is_dynamic',
+    'is_null',
+    'is_unsigned',
+    'common_type'
+]
 
 
 # ----------------------------------------------------------------------
@@ -80,6 +80,18 @@ def check_is_declared_explicit(lineno: int, id_: str, classname: str = 'variable
     return global_.SYMBOL_TABLE.check_is_declared(id_, lineno, classname)
 
 
+def check_is_callable(lineno: int, id_: str) -> bool:
+    entry = global_.SYMBOL_TABLE.get_entry(id_)
+    if entry is None:
+        return False
+
+    if entry.class_ not in (CLASS.function, CLASS.sub):
+        errmsg.syntax_error_unexpected_class(lineno, id_, entry.class_, CLASS.function)
+        return False
+
+    return True
+
+
 def check_type_is_explicit(lineno: int, id_: str, type_):
     assert isinstance(type_, symbols.TYPE)
     if type_.implicit:
@@ -96,7 +108,7 @@ def check_call_arguments(lineno: int, id_: str, args):
     if not global_.SYMBOL_TABLE.check_is_declared(id_, lineno, 'function'):
         return False
 
-    if not global_.SYMBOL_TABLE.check_class(id_, CLASS.function, lineno):
+    if not check_is_callable(lineno, id_):
         return False
 
     entry = global_.SYMBOL_TABLE.get_entry(id_)
@@ -428,3 +440,14 @@ def is_ender(node) -> bool:
                           'CONTINUE_DO', 'CONTINUE_FOR', 'CONTINUE_WHILE',
                           'EXIT_DO', 'EXIT_FOR', 'EXIT_WHILE',
                           'GOTO', 'RETURN', 'STOP'}
+
+
+def check_class(node, class_: CLASS, lineno: int) -> bool:
+    """ Returns whether the given node has CLASS.unknown or the given class_.
+    It False, it will emit a syntax error
+    """
+    if node.class_ == CLASS.unknown or node.class_ == class_:
+        return True
+
+    errmsg.syntax_error_unexpected_class(lineno, node.name, node.class_, class_)
+    return False

src/api/constants.py

@@ -187,26 +187,6 @@ def to_string(scope: 'SCOPE'):
         return scope.value
 
 
-@enum.unique
-class KIND(str, enum.Enum):
-    """ Enum kind
-    """
-    unknown = 'unknown'
-    var = 'var'
-    function = 'function'
-    sub = 'sub'
-    type = 'type'
-
-    @staticmethod
-    def is_valid(kind: Union[str, 'KIND']):
-        return kind in set(KIND)
-
-    @staticmethod
-    def to_string(kind: 'KIND'):
-        assert KIND.is_valid(kind)
-        return kind.value
-
-
 @enum.unique
 class CONVENTION(str, enum.Enum):
     unknown = 'unknown'

src/api/errmsg.py

@@ -15,8 +15,10 @@
 from typing import Callable
 from typing import Optional
 
-from . import global_
-from .config import OPTIONS
+from src.api import global_
+
+from src.api.constants import CLASS
+from src.api.config import OPTIONS
 
 
 # Exports only these functions. Others
@@ -125,7 +127,7 @@ def warning_implicit_type(lineno: int, id_: str, type_: str = None):
         return
 
     if type_ is None:
-        type_ = global_.DEFAULT_TYPE
+        type_ = global_.DEFAULT_TYPE.name
 
     warning(lineno, "Using default implicit type '%s' for '%s'" % (type_, id_))
 
@@ -315,4 +317,19 @@ def syntax_error_cannot_initialize_array_of_type(lineno: int, type_name: str):
     error(lineno, f"Cannot initialize array of type {type_name}")
 
 
+# ----------------------------------------
+#  Error, ID is a ... not a ...
+# ----------------------------------------
+def syntax_error_unexpected_class(lineno: int, id_name: str, wrong_class: CLASS, good_class: CLASS):
+    n1 = 'n' if wrong_class[0] in 'aeiou' else ''
+    n2 = 'n' if good_class[0] in 'aeiou' else ''
+    error(lineno, f"'{id_name}' is a{n1} {wrong_class.upper()}, not a{n2} {good_class.upper()}")
+
+
+# ----------------------------------------
+#  ID already declared as <class> at <line>
+# ----------------------------------------
+def syntax_error_already_declared(lineno: int, id_name: str, as_class: CLASS, at_lineno: int):
+    error(lineno, f"'{id_name}' already declared as {as_class} at {at_lineno}")
+
 # endregion

src/api/optimize.py

@@ -14,7 +14,7 @@
 from src.ast import NodeVisitor
 from src.api import errmsg
 
-from src.api.constants import TYPE, SCOPE, CLASS, KIND, CONVENTION
+from src.api.constants import TYPE, SCOPE, CLASS, CONVENTION
 from src.api.debug import __DEBUG__
 from src.api.errmsg import warning_not_used
 
@@ -87,8 +87,8 @@ def _visit(self, node: ToVisit):
 class UnreachableCodeVisitor(UniqueVisitor):
     """ Visitor to optimize unreachable code (and prune it).
     """
-    def visit_FUNCTION(self, node):
-        if node.kind == KIND.function and node.body.token == 'BLOCK' and \
+    def visit_FUNCTION(self, node: symbols.FUNCTION):
+        if node.class_ == CLASS.function and node.body.token == 'BLOCK' and \
                 (not node.body or node.body[-1].token != 'RETURN'):
             # String functions must *ALWAYS* return a value.
             # Put a sentinel ("dummy") return "" sentence that will be removed if other is detected

src/api/symboltable.py

@@ -16,10 +16,11 @@
 from typing import Optional
 from typing import Union
 
+from src.api import errmsg
 import src.api.check as check
 
-from .debug import __DEBUG__
-from . import global_
+from src.api.debug import __DEBUG__
+from src.api import global_
 
 from src import symbols
 from src.symbols.symbol_ import Symbol
@@ -254,7 +255,7 @@ def check_is_undeclared(self, id_: str, lineno: int, classname='identifier',
                           scope[id_].lineno))
         return False
 
-    def check_class(self, id_: str, class_, lineno: int, scope=None, show_error=True) -> bool:
+    def check_class(self, id_: str, class_: CLASS, lineno: int, scope: Scope = None, show_error=True) -> bool:
         """ Check the id is either undefined or defined with
         the given class.
 
@@ -268,24 +269,13 @@ def check_class(self, id_: str, class_, lineno: int, scope=None, show_error=True
         """
         assert CLASS.is_valid(class_)
         entry = self.get_entry(id_, scope)
-        if entry is None or entry.class_ == CLASS.unknown:  # Undeclared yet
+        if entry is None or entry.class_ in (CLASS.unknown, class_):  # Undeclared yet
             return True
 
-        if entry.class_ != class_:
-            if show_error:
-                if entry.class_ == CLASS.array:
-                    a1 = 'n'
-                else:
-                    a1 = ''
-                if class_ == CLASS.array:
-                    a2 = 'n'
-                else:
-                    a2 = ''
-                syntax_error(lineno, "identifier '%s' is a%s %s, not a%s %s" %
-                             (id_, a1, entry.class_, a2, class_))
-            return False
+        if show_error:
+            check.check_class(entry, class_, lineno)
 
-        return True
+        return False
 
     # -------------------------------------------------------------------------
     # Scope Management
@@ -354,7 +344,7 @@ def leave_scope(self, show_warnings=True):
                         warning_not_used(v.lineno, v.name, kind=kind)
 
         for entry in self.current_scope.values(filter_by_opt=True):  # Symbols of the current level
-            if entry.class_ is CLASS.unknown:
+            if entry.class_ == CLASS.unknown:
                 self.move_to_global_scope(entry.name)
 
         offset = self.compute_offsets(self.current_scope)
@@ -428,9 +418,8 @@ def access_id(self, id_: str, lineno: int, scope=None, default_type=None, defaul
                 default_type = symbols.TYPEREF(self.basic_types[global_.DEFAULT_IMPLICIT_TYPE],
                                                lineno, implicit=True)
 
-            result = self.declare_variable(id_, lineno, default_type)
+            result = self.declare_variable(id_, lineno, default_type, class_=default_class)
             result.declared = False  # It was implicitly declared
-            result.class_ = default_class
             return result
 
         # The entry was already declared. If it's type is auto and the default type is not None,
@@ -498,9 +487,10 @@ def access_func(self, id_: str, lineno: int, scope=None, default_type=None):
                 else:
                     default_type = symbols.TYPEREF(self.basic_types[global_.DEFAULT_TYPE], lineno, implicit=True)
 
-            return self.declare_func(id_, lineno, default_type)
+            return self.declare_func(id_, lineno, default_type, class_=CLASS.unknown)  # Declare SUB / Func
 
-        if not self.check_class(id_, CLASS.function, lineno, scope):
+        if result.class_ not in (CLASS.function, CLASS.sub, CLASS.unknown):
+            errmsg.syntax_error_unexpected_class(lineno, id_, result.class_, CLASS.function)
             return None
 
         return result
@@ -549,7 +539,7 @@ def access_label(self, id_: str, lineno: int, scope: Optional[Scope] = None):
 
         return result
 
-    def declare_variable(self, id_, lineno, type_, default_value=None):
+    def declare_variable(self, id_, lineno, type_, default_value=None, class_: CLASS = CLASS.var):
         """ Like the above, but checks that entry.declared is False.
         Otherwise raises an error.
 
@@ -567,11 +557,11 @@ def declare_variable(self, id_, lineno, type_, default_value=None):
                                      "%s:%i" % (id_, entry.filename, entry.lineno))
             return None
 
-        if not self.check_class(id_, CLASS.var, lineno, scope=self.current_scope):
+        if not self.check_class(id_, class_, lineno, scope=self.current_scope):
             return None
 
         entry = (self.get_entry(id_, scope=self.current_scope) or
-                 self.declare(id_, lineno, symbols.VAR(id_, lineno, class_=CLASS.var)))
+                 self.declare(id_, lineno, symbols.VAR(id_, lineno, class_=class_)))
         __DEBUG__("Entry %s declared with class %s at scope %s" % (entry.name, CLASS.to_string(entry.class_),
                                                                    self.current_scope.namespace))
 
@@ -588,7 +578,7 @@ def declare_variable(self, id_, lineno, type_, default_value=None):
 
         entry.scope = SCOPE.global_ if self.current_scope == self.global_scope else SCOPE.local
         entry.callable = False
-        entry.class_ = CLASS.var  # HINT: class_ attribute could be erased if access_id was used.
+        entry.class_ = class_  # Ensure class_ is set if variable was implicit
         entry.declared = True  # marks it as declared
 
         if entry.type_.implicit and entry.type_ != self.basic_types[TYPE.unknown]:
@@ -644,11 +634,10 @@ def declare_const(self, id_: str, lineno: int, type_, default_value):
                                      "%s:%i" % (id_, entry.filename, entry.lineno))
             return None
 
-        entry = self.declare_variable(id_, lineno, type_, default_value)
+        entry = self.declare_variable(id_, lineno, type_, default_value, class_=CLASS.const)
         if entry is None:
             return None
 
-        entry.class_ = CLASS.const
         return entry
 
     def declare_label(self, id_: str, lineno: int) -> Optional[SymbolLABEL]:
@@ -784,15 +773,13 @@ def declare_array(self, id_: str, lineno: int, type_, bounds, default_value=None
                                                                    self.current_scope))
         return entry
 
-    def declare_func(self, id_: str, lineno: int, type_=None):
+    def declare_func(self, id_: str, lineno: int, type_=None, class_=CLASS.function):
         """ 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.
         """
-        if not self.check_class(id_, 'function', lineno):
-            entry = self.get_entry(id_)  # Must not exist or have _class = None or Function and declared = False
-            an = 'an' if entry.class_.lower()[0] in 'aeio' else 'a'
-            syntax_error(lineno, "'%s' already declared as %s %s at %i" % (id_, an, entry.class_, entry.lineno))
+        assert class_ in (CLASS.function, CLASS.sub, CLASS.unknown)
+        if not self.check_class(id_, class_, lineno):
             return None
 
         entry = self.get_entry(id_)  # Must not exist or have _class = None or Function and declared = False
@@ -801,18 +788,15 @@ def declare_func(self, id_: str, lineno: int, type_=None):
                 syntax_error(lineno, "Duplicate function name '%s', previously defined at %i" % (id_, entry.lineno))
                 return None
 
-            if entry.class_ != CLASS.unknown and entry.callable is False:  # HINT: Must use is False here.
-                syntax_error_not_array_nor_func(lineno, id_)
-                return None
-
             if id_[-1] in DEPRECATED_SUFFIXES and entry.type_ != self.basic_types[SUFFIX_TYPE[id_[-1]]]:
                 syntax_error_func_type_mismatch(lineno, entry)
 
             if entry.token == 'VAR':  # This was a function used in advance
                 symbols.VAR.to_function(entry, lineno=lineno)
             entry.mangled = '%s_%s' % (self.current_namespace, entry.name)  # HINT: mangle for nexted scopes
+            entry.class_ = class_
         else:
-            entry = self.declare(id_, lineno, symbols.FUNCTION(id_, lineno, type_=type_))
+            entry = self.declare(id_, lineno, symbols.FUNCTION(id_, lineno, type_=type_, class_=class_))
 
         if entry.forwarded:
             entry.forwared = False  # No longer forwarded