Merge pull request #547 from boriel/refact/code_refact

Refact/code refact

Author: boriel

.gitignore

@@ -16,3 +16,4 @@ scratch/
 .coverage
 htmlcov/
 build/
+venv/

src/api/constants.py

@@ -9,8 +9,11 @@
 #                    the GNU General License
 # ----------------------------------------------------------------------
 
+import enum
 import os
 
+from typing import Optional
+
 from .decorator import classproperty
 
 
@@ -28,7 +31,7 @@
 # ----------------------------------------------------------------------
 
 
-class CLASS(object):
+class CLASS:
     """ Enums class constants
     """
     unknown = 'unknown'  # 0
@@ -69,115 +72,114 @@ def to_string(cls, class_):
         return cls._CLASS_NAMES[class_]
 
 
-class ARRAY(object):
+class ARRAY:
     """ Enums array constants
     """
     bound_size = 2  # This might change depending on arch, program, etc..
     bound_count = 2  # Size of bounds counter
     array_type_size = 1  # Size of array type
 
 
-class TYPE(object):
-    """ Enums type constants
+@enum.unique
+class TYPE(enum.IntEnum):
+    """ Enums primary type constants
     """
-    auto = unknown = None
-    byte_ = 1
+    unknown = 0
+    byte = 1
     ubyte = 2
     integer = 3
     uinteger = 4
-    long_ = 5
+    long = 5
     ulong = 6
     fixed = 7
-    float_ = 8
+    float = 8
     string = 9
 
-    TYPE_SIZES = {
-        byte_: 1, ubyte: 1,
-        integer: 2, uinteger: 2,
-        long_: 4, ulong: 4,
-        fixed: 4, float_: 5,
-        string: 2, unknown: 0
-    }
-
-    TYPE_NAMES = {
-        byte_: 'byte', ubyte: 'ubyte',
-        integer: 'integer', uinteger: 'uinteger',
-        long_: 'long', ulong: 'ulong',
-        fixed: 'fixed', float_: 'float',
-        string: 'string', unknown: 'none'
-    }
+    @classmethod
+    def type_size(cls, type_: 'TYPE'):
+        type_sizes = {
+            cls.byte: 1, cls.ubyte: 1,
+            cls.integer: 2, cls.uinteger: 2,
+            cls.long: 4, cls.ulong: 4,
+            cls.fixed: 4, cls.float: 5,
+            cls.string: 2, cls.unknown: 0
+        }
+        return type_sizes[type_]
 
     @classproperty
     def types(cls):
-        return tuple(cls.TYPE_SIZES.keys())
+        return set(TYPE)
 
     @classmethod
-    def size(cls, type_):
-        return cls.TYPE_SIZES.get(type_, None)
+    def size(cls, type_: 'TYPE'):
+        return cls.type_size(type_)
 
     @classproperty
     def integral(cls):
-        return (cls.byte_, cls.ubyte, cls.integer, cls.uinteger,
-                cls.long_, cls.ulong)
+        return {cls.byte, cls.ubyte, cls.integer, cls.uinteger,
+                cls.long, cls.ulong}
 
     @classproperty
     def signed(cls):
-        return (cls.byte_, cls.integer, cls.long_, cls.fixed, cls.float_)
+        return {cls.byte, cls.integer, cls.long, cls.fixed, cls.float}
 
     @classproperty
     def unsigned(cls):
-        return (cls.ubyte, cls.uinteger, cls.ulong)
+        return {cls.ubyte, cls.uinteger, cls.ulong}
 
     @classproperty
     def decimals(cls):
-        return (cls.fixed, cls.float_)
+        return {cls.fixed, cls.float}
 
     @classproperty
     def numbers(cls):
-        return tuple(list(cls.integral) + list(cls.decimals))
+        return set(cls.integral) | set(cls.decimals)
 
     @classmethod
-    def is_valid(cls, type_):
+    def is_valid(cls, type_: 'TYPE'):
         """ Whether the given type is
         valid or not.
         """
         return type_ in cls.types
 
     @classmethod
-    def is_signed(cls, type_):
+    def is_signed(cls, type_: 'TYPE'):
         return type_ in cls.signed
 
     @classmethod
-    def is_unsigned(cls, type_):
+    def is_unsigned(cls, type_: 'TYPE'):
         return type_ in cls.unsigned
 
     @classmethod
-    def to_signed(cls, type_):
+    def to_signed(cls, type_: 'TYPE'):
         """ Return signed type or equivalent
         """
         if type_ in cls.unsigned:
-            return {TYPE.ubyte: TYPE.byte_,
+            return {TYPE.ubyte: TYPE.byte,
                     TYPE.uinteger: TYPE.integer,
-                    TYPE.ulong: TYPE.long_}[type_]
+                    TYPE.ulong: TYPE.long}[type_]
         if type_ in cls.decimals or type_ in cls.signed:
             return type_
         return cls.unknown
 
-    @classmethod
-    def to_string(cls, type_):
+    @staticmethod
+    def to_string(type_: 'TYPE'):
         """ Return ID representation (string) of a type
         """
-        return cls.TYPE_NAMES[type_]
+        return type_.name
 
-    @classmethod
-    def to_type(cls, typename):
+    @staticmethod
+    def to_type(typename: str) -> Optional['TYPE']:
         """ Converts a type ID to name. On error returns None
         """
-        NAME_TYPES = {cls.TYPE_NAMES[x]: x for x in cls.TYPE_NAMES}
-        return NAME_TYPES.get(typename, None)
+        for t in TYPE:
+            if t.name == typename:
+                return t
+
+        return None
 
 
-class SCOPE(object):
+class SCOPE:
     """ Enum scopes
     """
     unknown = None
@@ -202,7 +204,7 @@ def to_string(cls, scope):
         return cls._names[scope]
 
 
-class KIND(object):
+class KIND:
     """ Enum kind
     """
     unknown = None
@@ -229,7 +231,7 @@ def to_string(cls, kind):
         return cls._NAMES.get(kind)
 
 
-class CONVENTION(object):
+class CONVENTION:
     unknown = None
     fastcall = '__fastcall__'
     stdcall = '__stdcall__'
@@ -268,4 +270,4 @@ def to_string(cls, convention):
 ID_TYPES = TYPE.types
 
 # Maps deprecated suffixes to types
-SUFFIX_TYPE = {'$': TYPE.string, '%': TYPE.integer, '&': TYPE.long_}
+SUFFIX_TYPE = {'$': TYPE.string, '%': TYPE.integer, '&': TYPE.long}

src/api/decorator.py

@@ -1,69 +1,16 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import collections
-import inspect
-import os
+from typing import Callable
 
 
-class classproperty(object):
-    ''' Decorator for class properties.
+class classproperty:
+    """ Decorator for class properties.
     Use @classproperty instead of @property to add properties
     to the class object.
-    '''
-    def __init__(self, fget):
+    """
+    def __init__(self, fget: Callable):
         self.fget = fget
 
     def __get__(self, owner_self, owner_cls):
         return self.fget(owner_cls)
-
-
-def check_type(*args, **kwargs):
-    ''' Checks the function types
-    '''
-    args = tuple(x if isinstance(x, collections.Iterable) else (x,) for x in args)
-    kwargs = {x: kwargs[x] if isinstance(kwargs[x], collections.Iterable) else (kwargs[x],) for x in kwargs}
-
-    def decorate(func):
-        types = args
-        kwtypes = kwargs
-        gi = "Got <{}> instead"
-        errmsg1 = "to be of type <{}>. " + gi
-        errmsg2 = "to be one of type ({}). " + gi
-        errar = "{}:{} expected '{}' "
-        errkw = "{}:{} expected {} "
-
-        def check(*ar, **kw):
-            line = inspect.getouterframes(inspect.currentframe())[1][2]
-            fname = os.path.basename(inspect.getouterframes(inspect.currentframe())[1][1])
-
-            for arg, type_ in zip(ar, types):
-                if type(arg) not in type_:
-                    if len(type_) == 1:
-                        raise TypeError((errar + errmsg1).format(fname, line, arg, type_[0].__name__,
-                                                                 type(arg).__name__))
-                    else:
-                        raise TypeError((errar + errmsg2).format(fname, line, arg,
-                                                                 ', '.join('<%s>' % x.__name__ for x in type_),
-                                                                 type(arg).__name__))
-            for kwarg in kw:
-                if kwtypes.get(kwarg, None) is None:
-                    continue
-                if type(kw[kwarg]) not in kwtypes[kwarg]:
-                    if len(kwtypes[kwarg]) == 1:
-                        raise TypeError((errkw + errmsg1).format(fname, line, kwarg, kwtypes[kwarg][0].__name__,
-                                                                 type(kw[kwarg]).__name__))
-                    else:
-                        raise TypeError((errkw + errmsg2).format(
-                            fname,
-                            line,
-                            kwarg,
-                            ', '.join('<%s>' % x.__name__ for x in kwtypes[kwarg]),
-                            type(kw[kwarg]).__name__)
-                        )
-
-            return func(*ar, **kw)
-
-        return check
-
-    return decorate

src/api/global_.py

@@ -57,13 +57,13 @@
 # ----------------------------------------------------------------------
 # Default var type when not specified (implicit) an can't be guessed
 # ----------------------------------------------------------------------
-DEFAULT_TYPE = TYPE.float_
+DEFAULT_TYPE = TYPE.float
 
 # ----------------------------------------------------------------------
 # Default variable type when not specified in DIM.
 # 'auto' => try to guess and if not, fallback to DEFAULT_TYPE
 # ----------------------------------------------------------------------
-DEFAULT_IMPLICIT_TYPE = TYPE.auto  # Use TYPE.auto for smart type guessing
+DEFAULT_IMPLICIT_TYPE = TYPE.unknown  # Use TYPE.auto for smart type guessing
 
 # ----------------------------------------------------------------------
 # Maximum number of errors to report before giving up.

src/api/optimize.py

@@ -11,7 +11,6 @@
 import src.api.check as chk
 
 from src import symbols
-from src.ast import Ast
 from src.ast import NodeVisitor
 from src.api import errmsg
 
@@ -65,7 +64,7 @@ def _visit(self, node: ToVisit):
         meth = getattr(self, f"visit_{node.obj.token}", self.generic_visit)
         return meth(node.obj)
 
-    def generic_visit(self, node: Ast):
+    def generic_visit(self, node: symbols.SYMBOL):
         for i, child in enumerate(node.children):
             node.children[i] = (yield self.visit(child))
 
@@ -86,6 +85,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 \
                 (not node.body or node.body[-1].token != 'RETURN'):
@@ -203,7 +204,7 @@ def visit_ADDRESS(self, node):
                 )
         yield node
 
-    def visit_BINARY(self, node):
+    def visit_BINARY(self, node: symbols.BINARY):
         node = (yield self.generic_visit(node))  # This might convert consts to numbers if possible
         # Retry folding
         yield symbols.BINARY.make_node(node.operator, node.left, node.right, node.lineno, node.func, node.type_)
@@ -370,10 +371,10 @@ def _visit_LABEL(self, node):
         else:
             yield node
 
-    @staticmethod
-    def generic_visit(node):
+    def generic_visit(self, node: symbols.SYMBOL):
         for i in range(len(node.children)):
             node.children[i] = (yield ToVisit(node.children[i]))
+
         yield node
 
     def _check_if_any_arg_is_an_array_and_needs_lbound_or_ubound(self, params: symbols.PARAMLIST,
@@ -417,12 +418,12 @@ class VariableVisitor(GenericVisitor):
     _parent_variable = None
     _visited: Set[symbols.SYMBOL] = set()
 
-    @staticmethod
-    def generic_visit(node: symbols.SYMBOL):  # type: ignore
+    def generic_visit(self, node: symbols.SYMBOL):
         if node not in VariableVisitor._visited:
             VariableVisitor._visited.add(node)
             for i in range(len(node.children)):
                 node.children[i] = yield ToVisit(node.children[i])
+
             yield node
 
     def has_circular_dependency(self, var_dependency: VarDependency) -> bool:

src/api/symboltable.py

@@ -435,7 +435,7 @@ def access_id(self, id_: str, lineno: int, scope=None, default_type=None, defaul
 
         # The entry was already declared. If it's type is auto and the default type is not None,
         # update its type.
-        if default_type is not None and result.type_ == self.basic_types[TYPE.auto]:
+        if default_type is not None and result.type_ == self.basic_types[TYPE.unknown]:
             result.type_ = default_type
             warning_implicit_type(lineno, id_, default_type.name)
 
@@ -493,8 +493,8 @@ def access_func(self, id_: str, lineno: int, scope=None, default_type=None):
         result = self.get_entry(id_, scope)
         if result is None:
             if default_type is None:
-                if global_.DEFAULT_IMPLICIT_TYPE == TYPE.auto:
-                    default_type = symbols.TYPEREF(self.basic_types[TYPE.auto], lineno, implicit=True)
+                if global_.DEFAULT_IMPLICIT_TYPE == TYPE.unknown:
+                    default_type = symbols.TYPEREF(self.basic_types[TYPE.unknown], lineno, implicit=True)
                 else:
                     default_type = symbols.TYPEREF(self.basic_types[global_.DEFAULT_TYPE], lineno, implicit=True)