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

jaclang/compiler/passes/main/type_checker_pass.py

@@ -0,0 +1,147 @@
+"""
+Type checker pass.
+
+This will perform type checking on the Jac program and accumulate any type
+errors found during the process in the pass's had_errors, had_warnings list.
+
+Reference:
+    Pyright: packages/pyright-internal/src/analyzer/checker.ts
+    craizy_type_expr branch: type_checker_pass.py
+"""
+
+import ast as py_ast
+import os
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.passes import UniPass
+from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
+from jaclang.runtimelib.utils import read_file_with_encoding
+
+from .pyast_load_pass import PyastBuildPass
+from .sym_tab_build_pass import SymTabBuildPass
+
+
+class TypeCheckPass(UniPass):
+    """Type checker pass for JacLang."""
+
+    # NOTE: This is done in the binder pass of pyright, however I'm doing this
+    # here, cause this will be the entry point of the type checker and we're not
+    # relying on the binder pass at the moment and we can go back to binder pass
+    # in the future if we needed it.
+    _BUILTINS_STUB_FILE_PATH = os.path.join(
+        os.path.dirname(__file__),
+        "../../../vendor/typeshed/stdlib/builtins.pyi",
+    )
+
+    # Cache the builtins module once it parsed.
+    _BUILTINS_MODULE: uni.Module | None = None
+
+    # REVIEW: Making the evaluator a static (singleton) variable to make sure only one
+    # instance is used across mulitple compilation units. This can also be attached to an
+    # attribute of JacProgram, however the evaluator is a temproary object that we dont
+    # want bound to the program for long term, Also the program is the one that will be
+    # dumped in the compiled bundle.
+    _EVALUATOR: TypeEvaluator | None = None
+
+    def before_pass(self) -> None:
+        """Initialize the checker pass."""
+        self._load_builtins_stub_module()
+        self._insert_builtin_symbols()
+
+    @property
+    def evaluator(self) -> TypeEvaluator:
+        """Return the type evaluator."""
+        if TypeCheckPass._EVALUATOR is None:
+            assert TypeCheckPass._BUILTINS_MODULE is not None
+            TypeCheckPass._EVALUATOR = TypeEvaluator(
+                builtins_module=TypeCheckPass._BUILTINS_MODULE,
+                program=self.prog,
+            )
+        return TypeCheckPass._EVALUATOR
+
+    # --------------------------------------------------------------------------
+    # Internal helper functions
+    # --------------------------------------------------------------------------
+
+    def _binding_builtins(self) -> bool:
+        """Return true if we're binding the builtins stub file."""
+        return self.ir_in == TypeCheckPass._BUILTINS_MODULE
+
+    def _load_builtins_stub_module(self) -> None:
+        """Return the builtins stub module.
+
+        This will parse and cache the stub file and return the cached module on
+        subsequent calls.
+        """
+        if self._binding_builtins() or TypeCheckPass._BUILTINS_MODULE is not None:
+            return
+
+        if not os.path.exists(TypeCheckPass._BUILTINS_STUB_FILE_PATH):
+            raise FileNotFoundError(
+                f"Builtins stub file not found at {TypeCheckPass._BUILTINS_STUB_FILE_PATH}"
+            )
+
+        file_content = read_file_with_encoding(TypeCheckPass._BUILTINS_STUB_FILE_PATH)
+        uni_source = uni.Source(file_content, TypeCheckPass._BUILTINS_STUB_FILE_PATH)
+        mod = PyastBuildPass(
+            ir_in=uni.PythonModuleAst(
+                py_ast.parse(file_content),
+                orig_src=uni_source,
+            ),
+            prog=self.prog,
+        ).ir_out
+        SymTabBuildPass(ir_in=mod, prog=self.prog)
+        TypeCheckPass._BUILTINS_MODULE = mod
+
+    def _insert_builtin_symbols(self) -> None:
+        if self._binding_builtins():
+            return
+
+        # TODO: Insert these symbols.
+        # Reference: pyright Binder.bindModule()
+        #
+        # List taken from https://docs.python.org/3/reference/import.html#__name__
+        # '__name__', '__loader__', '__package__', '__spec__', '__path__',
+        # '__file__', '__cached__', '__dict__', '__annotations__',
+        # '__builtins__', '__doc__',
+        assert (
+            TypeCheckPass._BUILTINS_MODULE is not None
+        ), "Builtins module is not loaded"
+        if self.ir_in.parent_scope is not None:
+            self.log_info("Builtins module is already bound, skipping.")
+            return
+        # Review: If we ever assume a module cannot have a parent scope, this will
+        # break that contract.
+        self.ir_in.parent_scope = TypeCheckPass._BUILTINS_MODULE
+
+    # --------------------------------------------------------------------------
+    # Ast walker hooks
+    # --------------------------------------------------------------------------
+
+    def exit_assignment(self, node: uni.Assignment) -> None:
+        """Pyright: Checker.visitAssignment(node: AssignmentNode): boolean."""
+        # TODO: In pyright this logic is present at evaluateTypesForAssignmentStatement
+        # and we're calling getTypeForStatement from here, This can be moved into the
+        # other place or we can keep it here.
+        #
+        # Grep this in pyright TypeEvaluator.ts:
+        # `} else if (node.d.leftExpr.nodeType === ParseNodeType.Name) {`
+        #
+        if len(node.target) == 1 and (node.value is not None):  # Simple assignment.
+            left_type = self.evaluator.get_type_of_expression(node.target[0])
+            right_type = self.evaluator.get_type_of_expression(node.value)
+            if not self.evaluator.assign_type(right_type, left_type):
+                self.log_error(f"Cannot assign {right_type} to {left_type}")
+        else:
+            pass  # TODO: handle
+
+    def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
+        """Handle the atom trailer node."""
+        self.evaluator.get_type_of_expression(node)
+
+    def exit_func_call(self, node: uni.FuncCall) -> None:
+        """Handle the function call node."""
+        # TODO:
+        # 1. Function Existence & Callable Validation
+        # 2. Argument Matching(count, types, names)
+        self.evaluator.get_type_of_expression(node)

jaclang/compiler/passes/tool/tests/fixtures/simple_walk_fmt.jac

@@ -53,7 +53,4 @@ with entry {
 }
 
 
-def generate_joke -> dict[str, str] by llm(
-    incl_info={"jokes_example" : self.jokes },
-    temperature=0.0
-);
+def generate_joke -> dict[str, str] by llm();

jaclang/compiler/program.py

@@ -26,6 +26,7 @@ from jaclang.compiler.passes.main import (
     SymTabBuildPass,
     SymTabLinkPass,
     Transform,
+    TypeCheckPass,
 )
 from jaclang.compiler.passes.tool import (
     DocIRGenPass,
@@ -46,6 +47,9 @@ ir_gen_sched = [
     CFGBuildPass,
     InheritancePass,
 ]
+type_check_sched: list = [
+    TypeCheckPass,
+]
 py_code_gen = [
     PyastGenPass,
     PyJacAstLinkPass,
@@ -102,12 +106,20 @@ class JacProgram:
         return mod
 
     def compile(
-        self, file_path: str, use_str: str | None = None, no_cgen: bool = False
+        self,
+        file_path: str,
+        use_str: str | None = None,
+        # TODO: Create a compilation options class and put the bellow
+        # options in it.
+        no_cgen: bool = False,
+        type_check: bool = False,
     ) -> uni.Module:
         """Convert a Jac file to an AST."""
         keep_str = use_str or read_file_with_encoding(file_path)
         mod_targ = self.parse_str(keep_str, file_path)
         self.run_schedule(mod=mod_targ, passes=ir_gen_sched)
+        if type_check:
+            self.run_schedule(mod=mod_targ, passes=type_check_sched)
         if not no_cgen:
             self.run_schedule(mod=mod_targ, passes=py_code_gen)
         return mod_targ
@@ -119,9 +131,11 @@ class JacProgram:
         BinderPass(ir_in=mod_targ, prog=self)
         return mod_targ
 
-    def build(self, file_path: str, use_str: str | None = None) -> uni.Module:
+    def build(
+        self, file_path: str, use_str: str | None = None, type_check: bool = False
+    ) -> uni.Module:
         """Convert a Jac file to an AST."""
-        mod_targ = self.compile(file_path, use_str)
+        mod_targ = self.compile(file_path, use_str, type_check=type_check)
         JacImportDepsPass(ir_in=mod_targ, prog=self)
         for mod in self.mod.hub.values():
             SymTabLinkPass(ir_in=mod, prog=self)

jaclang/compiler/type_system/__init__.py

@@ -0,0 +1 @@
+"""Jaclang type checking."""

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()