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

jaclang/compiler/passes/tool/doc_ir_gen_pass.py

@@ -484,6 +484,8 @@ class DocIRGenPass(UniPass):
                     indent_parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
+                if isinstance(i, uni.Token) and i.name == Tok.KW_BY:
+                    parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
 
     def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:

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

@@ -51,3 +51,6 @@ def test_run {
 with entry {
     test_run();
 }
+
+
+def generate_joke -> dict[str, str] by llm();

jaclang/compiler/program.py

@@ -11,6 +11,7 @@ import jaclang.compiler.unitree as uni
 from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes.main import (
     Alert,
+    BinderPass,
     CFGBuildPass,
     DeclImplMatchPass,
     DefUsePass,
@@ -25,12 +26,14 @@ from jaclang.compiler.passes.main import (
     SymTabBuildPass,
     SymTabLinkPass,
     Transform,
+    TypeCheckPass,
 )
 from jaclang.compiler.passes.tool import (
     DocIRGenPass,
     FuseCommentsPass,
     JacFormatPass,
 )
+from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.utils.log import logging
 
 
@@ -44,6 +47,9 @@ ir_gen_sched = [
     CFGBuildPass,
     InheritancePass,
 ]
+type_check_sched: list = [
+    TypeCheckPass,
+]
 py_code_gen = [
     PyastGenPass,
     PyJacAstLinkPass,
@@ -73,7 +79,7 @@ class JacProgram:
     def parse_str(self, source_str: str, file_path: str) -> uni.Module:
         """Convert a Jac file to an AST."""
         had_error = False
-        if file_path.endswith(".py"):
+        if file_path.endswith(".py") or file_path.endswith(".pyi"):
             parsed_ast = py_ast.parse(source_str)
             py_ast_ret = PyastBuildPass(
                 ir_in=uni.PythonModuleAst(
@@ -100,21 +106,36 @@ 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."""
-        if not use_str:
-            with open(file_path, "r", encoding="utf-8") as file:
-                use_str = file.read()
-        mod_targ = self.parse_str(use_str, file_path)
+        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
 
-    def build(self, file_path: str, use_str: str | None = None) -> uni.Module:
+    def bind(self, file_path: str, use_str: str | None = None) -> uni.Module:
+        """Bind the Jac module."""
+        keep_str = use_str or read_file_with_encoding(file_path)
+        mod_targ = self.parse_str(keep_str, file_path)
+        BinderPass(ir_in=mod_targ, prog=self)
+        return mod_targ
+
+    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)
@@ -141,9 +162,9 @@ class JacProgram:
     def jac_file_formatter(file_path: str) -> str:
         """Convert a Jac file to an AST."""
         prog = JacProgram()
-        with open(file_path) as file:
-            source = uni.Source(file.read(), mod_path=file_path)
-            prse: Transform = JacParser(root_ir=source, prog=prog)
+        source_str = read_file_with_encoding(file_path)
+        source = uni.Source(source_str, mod_path=file_path)
+        prse: Transform = JacParser(root_ir=source, prog=prog)
         for i in format_sched:
             prse = i(ir_in=prse.ir_out, prog=prog)
         prse.errors_had = prog.errors_had

jaclang/compiler/tests/test_sr_errors.py

@@ -0,0 +1,32 @@
+"""Test jac.lark grammar for Shift/Reduce errors."""
+
+import os
+
+import jaclang
+from jaclang.utils.test import TestCase
+
+try:
+    from lark import Lark
+    from lark.exceptions import GrammarError
+except ImportError:  # pragma: no cover - lark should be installed for tests
+    Lark = None  # type: ignore
+    GrammarError = Exception
+
+
+class TestJacGrammar(TestCase):
+    """Check that jac.lark has no shift/reduce conflicts."""
+
+    def test_no_shift_reduce_errors(self) -> None:
+        """Ensure jac.lark parses with strict mode."""
+        if Lark is None:
+            self.fail("lark library not available")
+
+        lark_path = os.path.join(os.path.dirname(jaclang.__file__), "compiler/jac.lark")
+        with open(lark_path, "r", encoding="utf-8") as f:
+            grammar = f.read()
+
+        # Lark's strict mode raises GrammarError on conflicts
+        try:
+            Lark(grammar, parser="lalr", start="start", strict=True)
+        except GrammarError as e:  # pragma: no cover - fail if conflicts
+            self.fail(f"Shift/reduce conflicts detected: {e}")

jaclang/compiler/type_system/__init__.py

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

jaclang/compiler/type_system/type_evaluator.py

@@ -0,0 +1,421 @@
+"""
+Type system evaluator for JacLang.
+
+PyrightReference:
+    packages/pyright-internal/src/analyzer/typeEvaluator.ts
+    packages/pyright-internal/src/analyzer/typeEvaluatorTypes.ts
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.type_system import types
+
+if TYPE_CHECKING:
+    from jaclang.compiler.program import JacProgram
+
+from .type_utils import ClassMember
+from .types import TypeBase
+
+
+@dataclass
+class PrefetchedTypes:
+    """Types whose definitions are prefetched and cached by the type evaluator."""
+
+    none_type_class: TypeBase | None = None
+    object_class: TypeBase | None = None
+    type_class: TypeBase | None = None
+    union_type_class: TypeBase | None = None
+    awaitable_class: TypeBase | None = None
+    function_class: TypeBase | None = None
+    method_class: TypeBase | None = None
+    tuple_class: TypeBase | None = None
+    bool_class: TypeBase | None = None
+    int_class: TypeBase | None = None
+    str_class: TypeBase | None = None
+    dict_class: TypeBase | None = None
+    module_type_class: TypeBase | None = None
+    typed_dict_class: TypeBase | None = None
+    typed_dict_private_class: TypeBase | None = None
+    supports_keys_and_get_item_class: TypeBase | None = None
+    mapping_class: TypeBase | None = None
+    template_class: TypeBase | None = None
+
+
+class TypeEvaluator:
+    """Type evaluator for JacLang."""
+
+    def __init__(self, builtins_module: uni.Module, program: "JacProgram") -> None:
+        """Initialize the type evaluator with prefetched types.
+
+        Implementation Note:
+        --------------------
+        Pyright is prefetching the builtins when an evaluation is requested
+        on a node and from that node it does lookup for the builtins scope
+        and does the prefetch once, however if we forgot to call prefetch
+        in some place then it will not be available in the evaluator, So we
+        are prefetching the builtins at the constructor level once.
+        """
+        self.builtins_module = builtins_module
+        self.program = program
+        self.prefetch = self._prefetch_types()
+
+    # 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)
+
+    # NOTE: This function doesn't exists in pyright, however it exists as a helper function
+    # for the following functions.
+    def _import_module_from_path(self, path: str) -> uni.Module:
+        """Import a module from the given path."""
+        # Get the module, if it's not loaded yet, compile and get it.
+        #
+        # TODO:
+        # We're not typechecking inside the module itself however we
+        # need to check if the module path is site-package or not and
+        # do typecheck inside as well.
+        mod: uni.Module
+        if path in self.program.mod.hub:
+            mod = self.program.mod.hub[path]
+        else:
+            mod = self.program.compile(path, no_cgen=True, type_check=False)
+            # FIXME: Inherit from builtin symbol table logic is currently implemented
+            # here and checker pass, however it should be in one location, since we're
+            # doing type_check=False, it doesn't set parent_scope to builtins, this
+            # needs to be done properly. The way jaclang handles symbol table is different
+            # than pyright, so we cannot strictly follow them, however as long as a new
+            # module has a parent scope as builtin scope, we're aligned with pyright.
+            if mod.parent_scope is None and mod is not self.builtins_module:
+                mod.parent_scope = self.builtins_module
+        return mod
+
+    def get_type_of_module(self, node: uni.ModulePath) -> types.ModuleType:
+        """Return the effective type of the module."""
+        if node.name_spec.type is not None:
+            return cast(types.ModuleType, node.name_spec.type)
+
+        mod: uni.Module = self._import_module_from_path(node.resolve_relative_path())
+        mod_type = types.ModuleType(
+            mod_name=node.name_spec.sym_name,
+            file_uri=Path(node.resolve_relative_path()).resolve(),
+            symbol_table=mod,
+        )
+
+        node.name_spec.type = mod_type
+        return mod_type
+
+    def get_type_of_module_item(self, node: uni.ModuleItem) -> types.TypeBase:
+        """Return the effective type of the module item."""
+        # Module item can be both a module or a member of a module.
+        # import from .. { mod }   # <-- Here mod is not a member but a module itself.
+        # import from mod { item } # <-- Here item is not a module but a member of mod.
+        if node.name_spec.type is not None:
+            return node.name_spec.type
+
+        import_node = node.parent_of_type(uni.Import)
+        if import_node.from_loc:
+
+            from_path = Path(import_node.from_loc.resolve_relative_path())
+            is_dir = from_path.is_dir() or (from_path.stem == "__init__")
+
+            # import from .. { mod }
+            if is_dir:
+                mod_dir = from_path.parent if not from_path.is_dir() else from_path
+                # FIXME: Implement module resolution properly.
+                for ext in (".jac", ".py", ".pyi"):
+                    if (path := (mod_dir / (node.name.value + ext)).resolve()).exists():
+                        mod = self._import_module_from_path(str(path))
+                        mod_type = types.ModuleType(
+                            mod_name=node.name_spec.sym_name,
+                            file_uri=path,
+                            symbol_table=mod,
+                        )
+                        # Cache the type.
+                        node.name_spec.type = mod_type
+
+                        # FIXME: goto definition works on imported symbol by checking if it's a MODULE
+                        # type and in that case it'll call resolve_relative_path on the parent node of
+                        # the symbol's definition node (a module path), So the goto definition to work
+                        # properly the category should be module on a module path, If we set like this
+                        # below should work but because of the above assumption (should be a mod path)
+                        # it won't, This needs to be discussed.
+                        #
+                        # node.name_spec._sym_category = uni.SymbolType.MODULE
+                        return node.name_spec.type
+
+            # import from mod { item }
+            else:
+                mod_type = self.get_type_of_module(import_node.from_loc)
+                if sym := mod_type.symbol_table.lookup(node.name.value, deep=True):
+                    node.name.sym = sym
+                    if node.alias:
+                        node.alias.sym = sym
+                    node.name_spec.type = self.get_type_of_symbol(sym)
+                    return node.name_spec.type
+
+        return types.UnknownType()
+
+    def get_type_of_class(self, node: uni.Archetype) -> types.ClassType:
+        """Return the effective type of the class."""
+        # Is this type already cached?
+        if node.name_spec.type is not None:
+            return cast(types.ClassType, node.name_spec.type)
+
+        cls_type = types.ClassType(
+            types.ClassType.ClassDetailsShared(
+                class_name=node.name_spec.sym_name,
+                symbol_table=node,
+                # TODO: Resolve the base class expression and pass them here.
+            ),
+            flags=types.TypeFlags.Instantiable,
+        )
+
+        # Cache the type, pyright is doing invalidateTypeCacheIfCanceled()
+        # we're not doing that any time sooner.
+        node.name_spec.type = cls_type
+        return cls_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:
+        # "foo" is not `str` but Literal["foo"], however for now we'll
+        # not considering that and make it work and will implement that
+        # later.
+        #
+        # see: getTypeOfString() in pyright (it requires parsing the sub
+        # file of the typing module).
+        assert self.prefetch.str_class is not None
+        return self.prefetch.str_class
+
+    def get_type_of_int(self, node: uni.Int) -> TypeBase:
+        """Return the effective type of the int."""
+        assert self.prefetch.int_class is not None
+        return self.prefetch.int_class
+
+    # Pyright equivalent function name = getTypeOfExpression();
+    def get_type_of_expression(self, node: uni.Expr) -> TypeBase:
+        """Return the effective type of the expression."""
+        # If it's alreay "cached" return it.
+        if node.type is not None:
+            return node.type
+
+        result = self._get_type_of_expression_core(node)
+        # If the context has an expected type, pyright does a compatibility and set
+        # a diagnostics here, I don't understand why that might be necessary here.
+
+        node.type = result  # Cache the result
+        return result
+
+    # Comments from pyright:
+    # // Determines if the source type can be assigned to the dest type.
+    # // If constraint are provided, type variables within the destType are
+    # // matched against existing type variables in the map. If a type variable
+    # // in the dest type is not in the type map already, it is assigned a type
+    # // and added to the map.
+    def assign_type(self, src_type: TypeBase, dest_type: TypeBase) -> bool:
+        """Assign the source type to the destination type."""
+        if types.TypeCategory.Unknown in (src_type.category, dest_type.category):
+            # NOTE: For now if we don't have the type info, we assume it's compatible.
+            # For strict mode we should disallow usage of unknown unless explicitly ignored.
+            return True
+        # FIXME: This logic is not valid, just here as a stub.
+        if types.TypeCategory.Unknown in (src_type.category, dest_type.category):
+            return True
+
+        if src_type == dest_type:
+            return True
+
+        if dest_type.is_class_instance() and src_type.is_class_instance():
+            assert isinstance(dest_type, types.ClassType)
+            assert isinstance(src_type, types.ClassType)
+            return self._assign_class(src_type, dest_type)
+
+        # FIXME: This is temporary.
+        return src_type == dest_type
+
+    def _assign_class(
+        self, src_type: types.ClassType, dest_type: types.ClassType
+    ) -> bool:
+        """Assign the source class type to the destination class type."""
+        if src_type.shared == dest_type.shared:
+            return True
+
+        # TODO: Search base classes and everything else pyright is doing.
+        return False
+
+    def _prefetch_types(self) -> "PrefetchedTypes":
+        """Return the prefetched types for the type evaluator."""
+        return PrefetchedTypes(
+            # TODO: Pyright first try load NoneType from typeshed and if it cannot
+            # then it set to unknown type.
+            none_type_class=types.UnknownType(),
+            object_class=self._get_builtin_type("object"),
+            type_class=self._get_builtin_type("type"),
+            # union_type_class=
+            # awaitable_class=
+            # function_class=
+            # method_class=
+            tuple_class=self._get_builtin_type("tuple"),
+            bool_class=self._get_builtin_type("bool"),
+            int_class=self._get_builtin_type("int"),
+            str_class=self._get_builtin_type("str"),
+            dict_class=self._get_builtin_type("dict"),
+            # module_type_class=
+            # typed_dict_class=
+            # typed_dict_private_class=
+            # supports_keys_and_get_item_class=
+            # mapping_class=
+            # template_class=
+        )
+
+    def _get_builtin_type(self, name: str) -> TypeBase:
+        """Return the built-in type with the given name."""
+        if (symbol := self.builtins_module.lookup(name)) is not None:
+            return self.get_type_of_symbol(symbol)
+        return types.UnknownType()
+
+    # This function is a combination of the bellow pyright functions.
+    #  - getDeclaredTypeOfSymbol
+    #  - getTypeForDeclaration
+    #
+    # Implementation Note:
+    # Pyright is actually have some duplicate logic for handling declared
+    # type and inferred type, we're going to unify them (if it's required
+    # in the future, we can refactor this).
+    def _get_type_of_symbol(self, symbol: uni.Symbol) -> TypeBase:
+        """Return the declared type of the symbol."""
+        node = symbol.decl.name_of
+        match node:
+            case uni.ModulePath():
+                return self.get_type_of_module(node)
+
+            case uni.ModuleItem():
+                return self.get_type_of_module_item(node)
+
+            case uni.Archetype():
+                return self.get_type_of_class(node)
+
+            # This actually defined in the function getTypeForDeclaration();
+            # Pyright has DeclarationType.Variable.
+            case uni.Name():
+                if isinstance(node.parent, uni.Assignment):
+                    if node.parent.type_tag is not None:
+                        annotation_type = self.get_type_of_expression(
+                            node.parent.type_tag.tag
+                        )
+                        return self._convert_to_instance(annotation_type)
+
+                    else:  # Assignment without a type annotation.
+                        if node.parent.value is not None:
+                            return self.get_type_of_expression(node.parent.value)
+
+            case uni.HasVar():
+                if node.type_tag is not None:
+                    annotation_type = self.get_type_of_expression(node.type_tag.tag)
+                    return self._convert_to_instance(annotation_type)
+                else:
+                    if node.value is not None:
+                        return self.get_type_of_expression(node.value)
+
+            # TODO: Implement for functions, parameters, explicit type
+            # annotations in assignment etc.
+        return types.UnknownType()
+
+    # Pyright equivalent function name = getTypeOfExpressionCore();
+    def _get_type_of_expression_core(self, expr: uni.Expr) -> TypeBase:
+        """Core function to get the type of the expression."""
+        match expr:
+
+            case uni.String() | uni.MultiString():
+                return self._convert_to_instance(self.get_type_of_string(expr))
+
+            case uni.Int():
+                return self._convert_to_instance(self.get_type_of_int(expr))
+
+            case uni.AtomTrailer():
+                # NOTE: Pyright is using CFG to figure out the member type by narrowing the base
+                # type and filtering the members. We're not doing that anytime sooner.
+                base_type = self.get_type_of_expression(expr.target)
+
+                if expr.is_attr:  # <expr>.member
+                    assert isinstance(expr.right, uni.Name)
+
+                    if isinstance(base_type, types.ModuleType):
+                        # getTypeOfMemberAccessWithBaseType()
+                        if sym := base_type.symbol_table.lookup(
+                            expr.right.value, deep=True
+                        ):
+                            expr.right.sym = sym
+                            return self.get_type_of_symbol(sym)
+                        return types.UnknownType()
+
+                    elif base_type.is_instantiable_class():
+                        assert isinstance(base_type, types.ClassType)
+                        if member := self._lookup_class_member(
+                            base_type, expr.right.value
+                        ):
+                            expr.right.sym = member.symbol
+                            return self.get_type_of_symbol(member.symbol)
+                        return types.UnknownType()
+
+                    elif base_type.is_class_instance():
+                        assert isinstance(base_type, types.ClassType)
+                        if member := self._lookup_object_member(
+                            base_type, expr.right.value
+                        ):
+                            expr.right.sym = member.symbol
+                            return self.get_type_of_symbol(member.symbol)
+                        return types.UnknownType()
+
+                elif expr.is_null_ok:  # <expr>?.member
+                    pass  # TODO:
+
+                else:  # <expr>[<expr>]
+                    pass  # TODO:
+
+            case uni.Name():
+                if symbol := expr.sym_tab.lookup(expr.value, deep=True):
+                    return self.get_type_of_symbol(symbol)
+
+            # TODO: More expressions.
+        return types.UnknownType()
+
+    def _convert_to_instance(self, jtype: TypeBase) -> TypeBase:
+        """Convert a class type to an instance type."""
+        # TODO: Grep pyright "Handle type[x] as a special case." They handle `type[x]` as a special case:
+        #
+        # foo: int = 42;       # <-- Here `int` is instantiable class and, become instance after this method.
+        # foo: type[int] = int # <-- Here `type[int]`, this should be `int` that's instantiable.
+        #
+        if jtype.is_instantiable_class():
+            assert isinstance(jtype, types.ClassType)
+            return jtype.clone_as_instance()
+        return jtype
+
+    def _lookup_class_member(
+        self, base_type: types.ClassType, member: str
+    ) -> ClassMember | None:
+        """Lookup the class member type."""
+        assert self.prefetch.int_class is not None
+        # FIXME: Pyright's way: Implement class member iterator (based on mro and the multiple inheritance)
+        # return the first found member from the iterator.
+
+        # NOTE: This is a simple implementation to make it work and more robust implementation will
+        # be done in a future PR.
+        if sym := base_type.lookup_member_symbol(member):
+            return ClassMember(sym, base_type)
+        return None
+
+    def _lookup_object_member(
+        self, base_type: types.ClassType, member: str
+    ) -> ClassMember | None:
+        """Lookup the object member type."""
+        assert self.prefetch.int_class is not None
+        if base_type.is_class_instance():
+            assert isinstance(base_type, types.ClassType)
+            # TODO: We need to implement Member lookup flags and set SkipInstanceMember to 0.
+            return self._lookup_class_member(base_type, member)
+        return None

jaclang/compiler/type_system/type_utils.py

@@ -0,0 +1,41 @@
+"""Functions that operate on Type objects.
+
+PyrightReference: packages/pyright-internal/src/analyzer/typeUtils.ts
+"""
+
+from jaclang.compiler.unitree import Symbol
+
+from . import types
+
+
+class ClassMember:
+    """Represents a member of a class."""
+
+    def __init__(self, symbol: Symbol, class_type: types.ClassType) -> None:
+        """Initialize obviously."""
+        self.symbol = symbol
+        self.class_type = class_type
+
+        # True if it is an instance or class member; it can be both a class and
+        # an instance member in cases where a class variable is overridden
+        # by an instance variable
+        self.is_instance_member = True
+        self.is_class_member = False
+
+        # Is the member in __slots__?
+        self.is_slots_member = False
+
+        # True if explicitly declared as "ClassVar" and therefore is
+        # a type violation if it is overwritten by an instance variable
+        self.is_class_var = False
+
+        # True if the member is read-only, such as with named tuples
+        # or frozen dataclasses.
+        self.is_read_only = False
+
+        # True if member has declared type, false if inferred
+        self.is_type_declared = False
+
+        # True if member lookup skipped an undeclared (inferred) type
+        # in a subclass before finding a declared type in a base class
+        self.skipped_undeclared_type = False