Merge pull request #548 from boriel/refact/code_refact

Refact/code refact

Author: boriel

src/api/constants.py

@@ -12,7 +12,7 @@
 import enum
 import os
 
-from typing import Optional
+from typing import Optional, Union
 
 from .decorator import classproperty
 
@@ -26,12 +26,13 @@
     os.path.abspath(os.path.dirname(os.path.abspath(__file__))), os.path.pardir)
 )
 
+
 # ----------------------------------------------------------------------
 # Class enums
 # ----------------------------------------------------------------------
 
-
-class CLASS:
+@enum.unique
+class CLASS(str, enum.Enum):
     """ Enums class constants
     """
     unknown = 'unknown'  # 0
@@ -41,35 +42,24 @@ class CLASS:
     label = 'label'  # 4 Labels
     const = 'const'  # 5  # constant literal value e.g. 5 or "AB"
     sub = 'sub'  # 6  # subroutine
-    type_ = 'type'  # 7  # type
-
-    _CLASS_NAMES = {
-        unknown: '(unknown)',
-        var: 'var',
-        array: 'array',
-        function: 'function',
-        label: 'label',
-        const: 'const',
-        sub: 'sub',
-        type_: 'type'
-    }
+    type = 'type'  # 7  # type
 
     @classproperty
     def classes(cls):
         return (cls.unknown, cls.var, cls.array, cls.function, cls.sub,
                 cls.const, cls.label)
 
     @classmethod
-    def is_valid(cls, class_):
+    def is_valid(cls, class_: Union[str, 'CLASS']):
         """ Whether the given class is
         valid or not.
         """
-        return class_ in cls.classes
+        return class_ in set(CLASS)
 
     @classmethod
-    def to_string(cls, class_):
+    def to_string(cls, class_: 'CLASS'):
         assert cls.is_valid(class_)
-        return cls._CLASS_NAMES[class_]
+        return class_.value
 
 
 class ARRAY:
@@ -179,83 +169,59 @@ def to_type(typename: str) -> Optional['TYPE']:
         return None
 
 
-class SCOPE:
+@enum.unique
+class SCOPE(str, enum.Enum):
     """ Enum scopes
     """
-    unknown = None
     global_ = 'global'
     local = 'local'
     parameter = 'parameter'
 
-    _names = {
-        unknown: 'unknown',
-        global_: 'global',
-        local: 'local',
-        parameter: 'parameter'
-    }
-
-    @classmethod
-    def is_valid(cls, scope):
-        return cls._names.get(scope, None) is not None
+    @staticmethod
+    def is_valid(scope: Union[str, 'SCOPE']):
+        return scope in set(SCOPE)
 
-    @classmethod
-    def to_string(cls, scope):
-        assert cls.is_valid(scope)
-        return cls._names[scope]
+    @staticmethod
+    def to_string(scope: 'SCOPE'):
+        assert SCOPE.is_valid(scope)
+        return scope.value
 
 
-class KIND:
+@enum.unique
+class KIND(str, enum.Enum):
     """ Enum kind
     """
-    unknown = None
+    unknown = 'unknown'
     var = 'var'
     function = 'function'
     sub = 'sub'
-    type_ = 'type'
-
-    _NAMES = {
-        unknown: '(unknown)',
-        var: 'variable',
-        function: 'function',
-        sub: 'subroutine',
-        type_: 'type'
-    }
+    type = 'type'
 
-    @classmethod
-    def is_valid(cls, kind):
-        return cls._NAMES.get(kind, None) is not None
+    @staticmethod
+    def is_valid(kind: Union[str, 'KIND']):
+        return kind in set(KIND)
 
-    @classmethod
-    def to_string(cls, kind):
-        assert cls.is_valid(kind)
-        return cls._NAMES.get(kind)
+    @staticmethod
+    def to_string(kind: 'KIND'):
+        assert KIND.is_valid(kind)
+        return kind.value
 
 
-class CONVENTION:
-    unknown = None
+@enum.unique
+class CONVENTION(str, enum.Enum):
+    unknown = 'unknown'
     fastcall = '__fastcall__'
     stdcall = '__stdcall__'
 
-    _NAMES = {
-        unknown: '(unknown)',
-        fastcall: '__fastcall__',
-        stdcall: '__stdcall__'
-    }
-
-    @classmethod
-    def is_valid(cls, convention):
-        return cls._NAMES.get(convention, None) is not None
-
-    @classmethod
-    def to_string(cls, convention):
-        assert cls.is_valid(convention)
-        return cls._NAMES[convention]
+    @staticmethod
+    def is_valid(convention: Union[str, 'CONVENTION']):
+        return convention in set(CONVENTION)
 
+    @staticmethod
+    def to_string(convention: 'CONVENTION'):
+        assert CONVENTION.is_valid(convention)
+        return convention.value
 
-# ----------------------------------------------------------------------
-# Identifier Class (variable, function, label, array)
-# ----------------------------------------------------------------------
-ID_CLASSES = CLASS.classes
 
 # ----------------------------------------------------------------------
 # Deprecated suffixes for variable names, such as "a$"

src/api/errmsg.py

@@ -270,7 +270,7 @@ def syntax_error_cant_convert_to_type(lineno: int, expr_str: str, type_: str):
 # Syntax error: is a SUB not a FUNCTION
 # ----------------------------------------
 def syntax_error_is_a_sub_not_a_func(lineno: int, name: str):
-    error(lineno, "'%s' is SUBROUTINE not a FUNCTION" % name)
+    error(lineno, "'%s' is a SUB not a FUNCTION" % name)
 
 
 # ----------------------------------------

src/api/symboltable.py

@@ -321,7 +321,7 @@ def entry_size(var_entry: Union[SymbolVAR, SymbolVARARRAY]):
         offset = 0
 
         for entry in entries:  # Symbols of the current level
-            if entry.class_ in (CLASS.function, CLASS.label, CLASS.type_):
+            if entry.class_ in (CLASS.function, CLASS.label, CLASS.type):
                 continue
 
             # Local variables offset
@@ -832,7 +832,7 @@ def check_labels(self):
         """ Checks if all the labels has been declared
         """
         for entry in self.labels:
-            self.check_is_declared(entry.name, entry.lineno, CLASS.label)
+            self.check_is_declared(entry.name, entry.lineno, CLASS.label.value)
 
     def check_classes(self, scope=-1):
         """ Check if pending identifiers are defined or not. If not,

src/symbols/type_.py

@@ -29,7 +29,7 @@ def __init__(self, name: str, lineno: int, *children):
         self.lineno = lineno  # The line the type was defined. Line 0 = basic type
         self.final = self  # self.final always return the original aliased type (if this type is an alias)
         self.caseins = OPTIONS.case_insensitive  # Whether this ID is case insensitive or not
-        self.class_ = CLASS.type_
+        self.class_ = CLASS.type
         self.accessed = False  # Whether this type has been used or not
 
     def __repr__(self):

tests/functional/test_errmsg.txt

@@ -15,9 +15,9 @@ doloop2.bas:4: warning: Variable 'a' is never used
 dowhile1.bas:1: warning: Condition is always True
 dowhile1.bas:1: warning: Empty loop
 >>> process_file('subcall1.bas')
-subcall1.bas:6: error: 'test' is SUBROUTINE not a FUNCTION
+subcall1.bas:6: error: 'test' is a SUB not a FUNCTION
 >>> process_file('subcall2.bas')
-subcall2.bas:6: error: 'test' is a SUBROUTINE, not a FUNCTION
+subcall2.bas:6: error: 'test' is a SUB, not a FUNCTION
 >>> process_file('prepro05.bi')
 prepro05.bi:2: warning: [W510] "test" redefined (previous definition at prepro05.bi:2)
 >>> process_file('prepro07.bi')
@@ -86,7 +86,7 @@ strict.bas:4: error: strict mode: missing type declaration for 'a'
 >>> process_file('errletfunc.bas')
 errletfunc.bas:5: error: Cannot assign a value to 'x'. It's not a variable
 >>> process_file('read0.bas')
-read0.bas:12: error: 'x' is SUBROUTINE not a FUNCTION
+read0.bas:12: error: 'x' is a SUB not a FUNCTION
 >>> process_file('read1.bas')
 read1.bas:11: error: Cannot read 'x'. It's an array
 >>> process_file('read3.bas')