jaclang 0.8.6__py3-none-any.whl → 0.8.7__py3-none-any.whl

jaclang/compiler/type_system/operations.py

@@ -0,0 +1,104 @@
+# flake8: noqa: I300
+"""Provides type evaluation logic for unary, binary, augmented assignment and ternary operators.
+
+PyrightReference: packages/pyright-internal/src/analyzer/operations.ts
+"""
+
+from typing import TYPE_CHECKING
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.constant import Tokens as Tok
+
+from . import types as jtypes
+
+if TYPE_CHECKING:
+    # Type evaluator is the one depends on this module and not the way around.
+    # however this module needs a reference to the type evaluator.
+    from .type_evaluator import TypeEvaluator
+
+
+# Maps binary operators to the magic methods that implement them.
+BINARY_OPERATOR_MAP: dict[str, tuple[str, str]] = {
+    Tok.PLUS: ("__add__", "__radd__"),
+    Tok.MINUS: ("__sub__", "__rsub__"),
+    Tok.STAR_MUL: ("__mul__", "__rmul__"),
+    Tok.FLOOR_DIV: ("__floordiv__", "__rfloordiv__"),
+    Tok.DIV: ("__truediv__", "__rtruediv__"),
+    Tok.MOD: ("__mod__", "__rmod__"),
+    Tok.STAR_POW: ("__pow__", "__rpow__"),
+    Tok.DECOR_OP: ("__matmul__", "__rmatmul__"),
+    Tok.BW_AND: ("__and__", "__rand__"),
+    Tok.BW_OR: ("__or__", "__ror__"),
+    Tok.BW_XOR: ("__xor__", "__rxor__"),
+    Tok.LSHIFT: ("__lshift__", "__rlshift__"),
+    Tok.RSHIFT: ("__rshift__", "__rrshift__"),
+    Tok.EE: ("__eq__", "__eq__"),
+    Tok.NE: ("__ne__", "__ne__"),
+    Tok.LT: ("__lt__", "__gt__"),
+    Tok.LTE: ("__le__", "__ge__"),
+    Tok.GT: ("__gt__", "__lt__"),
+    Tok.GTE: ("__ge__", "__le__"),
+}
+
+
+# Mirror of the `export function getTypeOfBinaryOperation` function in pyright.
+def get_type_of_binary_operation(
+    evaluator: "TypeEvaluator", expr: uni.BinaryExpr
+) -> jtypes.TypeBase:
+    """Return the binary operator's jtype."""
+    left_type = evaluator.get_type_of_expression(expr.left)
+    right_type = evaluator.get_type_of_expression(expr.right)
+
+    # TODO: Check how pyright is dealing with chaining operation (a < b < c < d) and
+    # it handles here with the condition `if operatorSupportsChaining()`.:
+
+    # TODO:
+    # Is this a "|" operator used in a context where it is supposed to be
+    # interpreted as a union operator?
+
+    # pyright is using another function however I don't see the need of it yet, so imma use
+    # the logic here, if needed define `validateBinaryOperation` for re-usability.
+
+    # TODO: Handle and, or
+    #
+    # <left> and <right>  <--- This is equlavent to the bellow
+    #
+    # def left_and_right(left, right):
+    #     if bool(left):
+    #         return left
+    #     return right
+    #
+    # And the type will be Union[left.type, right.type]
+    #
+
+    # NOTE: in will call `__contains__` magic method in custom type and should return `bool`
+    # however it can technically return anything otherthan `bool` and pyright is handing that way
+    # I don't see `__str__` method return anything other than string should be valid either.
+    if (expr.op in (Tok.KW_IS, Tok.KW_ISN, Tok.KW_IN, Tok.KW_NIN)) and (
+        evaluator.prefetch.bool_class is not None
+    ):
+        evaluator._convert_to_instance(evaluator.prefetch.bool_class)
+
+    # TODO: `expr.op` can be of 3 types, Token, connect, disconnect.
+    if isinstance(expr.op, uni.Token) and (expr.op.name in BINARY_OPERATOR_MAP):
+        # TODO: validateArithmeticOperation() has more cases and special conditions that we may
+        # need to implement in the future however in this simple case we're implementing the
+        # bare minimal checking.
+        magic, rmagic = BINARY_OPERATOR_MAP[expr.op.name]
+
+        # TODO: Handle overloaded call check:
+        # Grep this in pyright typeEvaluator.ts:
+        #    callResult.overloadsUsedForCall.forEach((overload) => {
+        #       overloadsUsedForCall.push(overload);
+        #       ...
+        #    });
+
+        # FIXME: We need to have validateCallArgs() method and do a check here before returning.
+        return (
+            evaluator.get_type_of_magic_method_call(left_type, magic)
+            or evaluator.get_type_of_magic_method_call(right_type, rmagic)
+            or jtypes.UnknownType()
+        )
+
+    # TODO: Handle for connect and disconnect operators.
+    return jtypes.UnknownType()

jaclang/compiler/type_system/type_evaluator.py

@@ -16,6 +16,7 @@ from jaclang.compiler.type_system import types
 if TYPE_CHECKING:
     from jaclang.compiler.program import JacProgram
 
+from . import operations
 from .type_utils import ClassMember
 from .types import TypeBase
 
@@ -44,6 +45,21 @@ class PrefetchedTypes:
     template_class: TypeBase | None = None
 
 
+@dataclass
+class SymbolResolutionStackEntry:
+    """Represents a single entry in the symbol resolution stack."""
+
+    symbol: uni.Symbol
+
+    # Initially true, it's set to false if a recursion
+    # is detected.
+    is_result_valid: bool = True
+
+    # Some limited forms of recursion are allowed. In these
+    # cases, a partially-constructed type can be registered.
+    partial_type: TypeBase | None = None
+
+
 class TypeEvaluator:
     """Type evaluator for JacLang."""
 
@@ -58,14 +74,55 @@ class TypeEvaluator:
         in some place then it will not be available in the evaluator, So we
         are prefetching the builtins at the constructor level once.
         """
+        self.symbol_resolution_stack: list[SymbolResolutionStackEntry] = []
         self.builtins_module = builtins_module
         self.program = program
         self.prefetch = self._prefetch_types()
 
+    # -------------------------------------------------------------------------
+    # Symbol resolution stack
+    # -------------------------------------------------------------------------
+
+    def get_index_of_symbol_resolution(self, symbol: uni.Symbol) -> int | None:
+        """Get the index of a symbol in the resolution stack."""
+        for i, entry in enumerate(self.symbol_resolution_stack):
+            if entry.symbol == symbol:
+                return i
+        return None
+
+    def push_symbol_resolution(self, symbol: uni.Symbol) -> bool:
+        """
+        Push a symbol onto the resolution stack.
+
+        Return False if recursion detected and in that case it won't push the symbol.
+        """
+        idx = self.get_index_of_symbol_resolution(symbol)
+        if idx is not None:
+            # Mark all of the entries between these two as invalid.
+            for i in range(idx, len(self.symbol_resolution_stack)):
+                entry = self.symbol_resolution_stack[i]
+                entry.is_result_valid = False
+            return False
+        self.symbol_resolution_stack.append(SymbolResolutionStackEntry(symbol=symbol))
+        return True
+
+    def pop_symbol_resolution(self, symbol: uni.Symbol) -> bool:
+        """Pop a symbol from the resolution stack."""
+        popped_entry = self.symbol_resolution_stack.pop()
+        assert popped_entry.symbol == symbol
+        return popped_entry.is_result_valid
+
     # Pyright equivalent function name = getEffectiveTypeOfSymbol.
     def get_type_of_symbol(self, symbol: uni.Symbol) -> TypeBase:
         """Return the effective type of the symbol."""
-        return self._get_type_of_symbol(symbol)
+        if self.push_symbol_resolution(symbol):
+            try:
+                return self._get_type_of_symbol(symbol)
+            finally:
+                self.pop_symbol_resolution(symbol)
+
+        # If we reached here that means we have a cyclic symbolic reference.
+        return types.UnknownType()
 
     # NOTE: This function doesn't exists in pyright, however it exists as a helper function
     # for the following functions.
@@ -92,10 +149,13 @@ class TypeEvaluator:
                 mod.parent_scope = self.builtins_module
         return mod
 
-    def get_type_of_module(self, node: uni.ModulePath) -> types.ModuleType:
+    def get_type_of_module(self, node: uni.ModulePath) -> types.TypeBase:
         """Return the effective type of the module."""
         if node.name_spec.type is not None:
             return cast(types.ModuleType, node.name_spec.type)
+        if not Path(node.resolve_relative_path()).exists():
+            node.name_spec.type = types.UnknownType()
+            return node.name_spec.type
 
         mod: uni.Module = self._import_module_from_path(node.resolve_relative_path())
         mod_type = types.ModuleType(
@@ -149,6 +209,11 @@ class TypeEvaluator:
             # import from mod { item }
             else:
                 mod_type = self.get_type_of_module(import_node.from_loc)
+                if not isinstance(mod_type, types.ModuleType):
+                    node.name_spec.type = types.UnknownType()
+                    # TODO: Add diagnostic that from_loc is not accessible.
+                    # Eg: 'Import "scipy" could not be resolved'
+                    return node.name_spec.type
                 if sym := mod_type.symbol_table.lookup(node.name.value, deep=True):
                     node.name.sym = sym
                     if node.alias:
@@ -178,6 +243,31 @@ class TypeEvaluator:
         node.name_spec.type = cls_type
         return cls_type
 
+    def get_type_of_ability(self, node: uni.Ability) -> TypeBase:
+        """Return the effective type of an ability."""
+        if node.name_spec.type is not None:
+            return node.name_spec.type
+
+        if not isinstance(node.signature, uni.FuncSignature):
+            node.name_spec.type = types.UnknownType()
+            return node.name_spec.type
+
+        if not isinstance(node.signature.return_type, uni.Expr):
+            node.name_spec.type = types.UnknownType()
+            return node.name_spec.type
+
+        return_type = self._convert_to_instance(
+            self.get_type_of_expression(node.signature.return_type)
+        )
+        func_type = types.FunctionType(
+            func_name=node.name_spec.sym_name,
+            return_type=return_type,
+            parameters=[],  # TODO:
+        )
+
+        node.name_spec.type = func_type
+        return func_type
+
     def get_type_of_string(self, node: uni.String | uni.MultiString) -> TypeBase:
         """Return the effective type of the string."""
         # FIXME: Strings are a type of LiteralString type:
@@ -236,6 +326,29 @@ class TypeEvaluator:
         # FIXME: This is temporary.
         return src_type == dest_type
 
+    # TODO: This should take an argument list as parameter.
+    def get_type_of_magic_method_call(
+        self, obj_type: TypeBase, method_name: str
+    ) -> TypeBase | None:
+        """Return the effective return type of a magic method call."""
+        if obj_type.category == types.TypeCategory.Class:
+            # TODO: getTypeOfBoundMember() <-- Implement this if needed, for the simple case
+            # we'll directly call member lookup.
+            #
+            # WE'RE DAVIATING FROM PYRIGHT FOR THIS METHOD HEAVILY HOWEVER THIS CAN BE RE-WRITTEN IF NEEDED.
+            #
+            assert isinstance(obj_type, types.ClassType)  # <-- To make typecheck happy.
+            if member := self._lookup_class_member(obj_type, method_name):
+                member_ty = self.get_type_of_symbol(member.symbol)
+                if isinstance(member_ty, types.FunctionType):
+                    return member_ty.return_type
+                # If we reached here, magic method is not a function.
+                # 1. recursively check __call__() on the type, TODO
+                # 2. if any or unknown, return getUnknownTypeForCallable() TODO
+                # 3. return undefined.
+                return None
+        return None
+
     def _assign_class(
         self, src_type: types.ClassType, dest_type: types.ClassType
     ) -> bool:
@@ -298,6 +411,9 @@ class TypeEvaluator:
             case uni.Archetype():
                 return self.get_type_of_class(node)
 
+            case uni.Ability():
+                return self.get_type_of_ability(node)
+
             # This actually defined in the function getTypeForDeclaration();
             # Pyright has DeclarationType.Variable.
             case uni.Name():
@@ -376,8 +492,31 @@ class TypeEvaluator:
                 else:  # <expr>[<expr>]
                     pass  # TODO:
 
+            case uni.AtomUnit():
+                return self.get_type_of_expression(expr.value)
+
+            case uni.FuncCall():
+                caller_type = self.get_type_of_expression(expr.target)
+                if isinstance(caller_type, types.FunctionType):
+                    return caller_type.return_type or types.UnknownType()
+                if (
+                    isinstance(caller_type, types.ClassType)
+                    and caller_type.is_instantiable_class()
+                ):
+                    return caller_type.clone_as_instance()
+                if caller_type.is_class_instance():
+                    magic_call_ret = self.get_type_of_magic_method_call(
+                        caller_type, "__call__"
+                    )
+                    if magic_call_ret:
+                        return magic_call_ret
+
+            case uni.BinaryExpr():
+                return operations.get_type_of_binary_operation(self, expr)
+
             case uni.Name():
                 if symbol := expr.sym_tab.lookup(expr.value, deep=True):
+                    expr.sym = symbol
                     return self.get_type_of_symbol(symbol)
 
             # TODO: More expressions.