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

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

@@ -1,18 +1,178 @@
-class SemTokManager {
+#this file is part of formatter tests and is not meant to be run
+ class SemTokManager {
     """Initialize semantic token manager."""
     def init(self: SemTokManager, ir: uni.Module) -> None {
-        self.sem_tokens: List[int] = self.gen_sem_tokens(ir);
         self.aaaaastatic_sem_tokens:
-            List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]] =
-            self.gen_sem_tok_node(ir);
+            List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]] = self.gen_sem_tok_node(
+            ir
+        );
     }
 }
 
 
-def init(
-    self: ModuleManager,
-    program: JacProgram,
-    sem_managers: <>dict,
-    program2: JacProgram,
-    sem_managers2: <>dict
-) -> None { }
+def walrus_example() {
+    if ((x := 10) > 5) {
+        print(x);
+        b = a(
+            11111111111111111111111111111111111111111111111111111111111111111111111111
+        );
+    }
+}
+
+
+with entry {
+    c = (
+        a()
+        if 1 and
+        isinstance(a, int) and
+        isinstance(a, int) and
+        isinstance(a, int) and
+        isinstance(a, int) and
+        isinstance(a, int)
+        else (
+            999
+            if isinstance(a, int) and
+            isinstance(a, int) and
+            isinstance(a, int) and
+            isinstance(4, bool)
+            else 7
+        )
+    );
+    print(
+        """This is a long
+        line of code."""
+    );
+}
+
+
+class ModuleManager {
+    def clear_alerts_for_file(self: ModuleManager, file_path_fs: str) -> None {
+        #list comprehension example
+        self.warnings_had = [
+            w
+            for w in self.program
+            if w.loc.mod_path != file_path_fs
+        ];
+        self.program.errors_had = [
+            e
+            for e in self.program.errors_haddddddddd
+            if e.loc.mod_path != file_path_fs
+        ];
+        self.program.errors_had = [
+            e
+            for e in self.program.errors_haddddddddddddddddddddddddddddddddddddddddd
+            if e.loc.mod_path != file_path_fs
+        ];
+        # dict comprehension example
+        squares_dict = {x : x ** 2 for x in numbers};
+        squares_dict = {
+            x : x ** 2 for x in numberssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        squares_dict = {
+            x : x ** 2
+            for x in numbersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        # set comprehension example
+        squares_set = {x ** 2 for x in numbers};
+        squares_set = {
+            x ** 2 for x in numberssssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        squares_set = {
+            x ** 2
+            for x in numbersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        # generator comprehension example
+        squares_gen = (x ** 2 for x in numbers);
+        squares_gen = (
+            x ** 2 for x in numberssssssssssssssssssssssssssssssssssssssssssssssssssss
+        );
+        squares_gen = (
+            x ** 2
+            for x in numbersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
+        );
+    }
+}
+
+
+## expr as item extra space issue
+ with entry {
+    with open(f"Apple{apple}.txt") as f {
+        # Fix syntax highlighting
+        print(
+            f.read()
+        );
+    }
+}
+
+
+def func_with_very_long_params(
+    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: int,
+    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: int,
+) -> None {
+    print(
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+    );
+}
+
+
+def func_with_long_params(
+    aaaaaaaaaaaaaaaaaaaaaa: int, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: int,
+) -> None {
+    print(
+        aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, 1111111111111
+    );
+}
+
+
+def func_with_short_params(a: int, b: int) -> None {
+    print(a + b + c[5:]);
+}
+
+
+with entry {
+    if (
+        node_selected and
+        node_selected.find_parent_of_type(uni.Archetype) or
+        node_selected.find_parent_of_type(uni.ImplDef)
+    ) {
+        self_symbol = [
+            lspt.CompletionItem(label='self', kind=lspt.CompletionItemKind.Variable)
+        ];
+    } else {
+        self_symbol = [];
+    }
+    x = (
+        1222222222 and
+        2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
+    );
+    a = 4 if True else 4;
+}
+
+
+"""Return diagnostics."""
+def gen_diagnostics(
+    from_path: str, errors: list[Alert], warnings: list[Alert]
+) -> list[lspt.Diagnostic] {
+    if (
+        isinstance(node_selected, uni.Name) and
+        node_selected.parent and
+        isinstance(node_selected.parent, uni.ModulePath)
+    ) {
+        node_selected = node_selected.name_of;
+    } elif (
+        isinstance(node_selected, uni.Name) and
+        node_selected.parent and
+        isinstance(node_selected.parent, uni.ModulePath)
+    ) {
+        spec = node_selected.parent.parent.abs_path;
+    }
+}
+
+
+@decorator
+def x() { }
+
+
+@decorator()
+class KK {}

jaclang/compiler/passes/transform.py

@@ -9,7 +9,7 @@ from typing import Generic, Optional, TYPE_CHECKING, Type, TypeVar
 from jaclang.compiler.codeinfo import CodeLocInfo
 from jaclang.compiler.unitree import UniNode
 from jaclang.settings import settings
-from jaclang.utils.helpers import pretty_print_source_location
+from jaclang.utils.helpers import ANSIColors, pretty_print_source_location
 from jaclang.utils.log import logging
 
 if TYPE_CHECKING:
@@ -39,7 +39,7 @@ class Alert:
         """Return string representation of alert."""
         return self.as_log()
 
-    def as_log(self) -> str:
+    def as_log(self, *, colors: bool = False) -> str:
         """Return the alert as a single line log as opposed to the pretty print."""
         file_path: str = self.loc.mod_path
         if file_path == "":
@@ -47,20 +47,24 @@ class Alert:
 
         line: int = self.loc.first_line
         column: int = self.loc.col_start
-        return f"{file_path}:{line}:{column} {self.msg}"
 
-    def pretty_print(self) -> str:
-        """Pretty pritns the Alert to show the alert with source location."""
+        # TODO: Set if the alert is error or warning and color accordingly.
+        msg = self.msg if not colors else f"{ANSIColors.RED}{self.msg}{ANSIColors.END}"
+        return f"{file_path}:{line}:{column} {msg}"
+
+    def pretty_print(self, *, colors: bool = False) -> str:
+        """Pretty prints the Alert to show the alert with source location."""
         pretty_dump = pretty_print_source_location(
             self.loc.mod_path,
             self.loc.orig_src.code,
             self.loc.first_line,
             self.loc.pos_start,
             self.loc.pos_end,
+            colors=colors,
         )
         if pretty_dump != "":
             pretty_dump = "\n" + pretty_dump
-        return self.as_log() + pretty_dump
+        return self.as_log(colors=colors) + pretty_dump
 
 
 class Transform(ABC, Generic[T, R]):
@@ -115,7 +119,7 @@ class Transform(ABC, Generic[T, R]):
         )
         self.errors_had.append(alrt)
         self.prog.errors_had.append(alrt)
-        self.logger.error(alrt.as_log())
+        # self.logger.error(alrt.as_log())
 
     def log_warning(self, msg: str, node_override: Optional[UniNode] = None) -> None:
         """Pass Error."""
@@ -126,7 +130,7 @@ class Transform(ABC, Generic[T, R]):
         )
         self.warnings_had.append(alrt)
         self.prog.warnings_had.append(alrt)
-        self.logger.warning(alrt.as_log())
+        # self.logger.warning(alrt.as_log())
 
     def log_info(self, msg: str) -> None:
         """Log info."""

jaclang/compiler/program.py

@@ -15,16 +15,15 @@ from jaclang.compiler.passes.main import (
     CFGBuildPass,
     DeclImplMatchPass,
     DefUsePass,
-    InheritancePass,
     JacAnnexPass,
     JacImportDepsPass,
+    PreDynamoPass,
     PyBytecodeGenPass,
     PyJacAstLinkPass,
     PyastBuildPass,
     PyastGenPass,
     SemDefMatchPass,
     SymTabBuildPass,
-    SymTabLinkPass,
     Transform,
     TypeCheckPass,
 )
@@ -33,7 +32,9 @@ from jaclang.compiler.passes.tool import (
     FuseCommentsPass,
     JacFormatPass,
 )
+from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
 from jaclang.runtimelib.utils import read_file_with_encoding
+from jaclang.settings import settings
 from jaclang.utils.log import logging
 
 
@@ -45,7 +46,6 @@ ir_gen_sched = [
     DefUsePass,
     SemDefMatchPass,
     CFGBuildPass,
-    InheritancePass,
 ]
 type_check_sched: list = [
     TypeCheckPass,
@@ -67,6 +67,13 @@ class JacProgram:
         self.py_raise_map: dict[str, str] = {}
         self.errors_had: list[Alert] = []
         self.warnings_had: list[Alert] = []
+        self.type_evaluator: TypeEvaluator | None = None
+
+    def get_type_evaluator(self) -> TypeEvaluator:
+        """Return the type evaluator."""
+        if not self.type_evaluator:
+            self.type_evaluator = TypeEvaluator(program=self)
+        return self.type_evaluator
 
     def get_bytecode(self, full_target: str) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
@@ -120,7 +127,10 @@ class JacProgram:
         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:
+        # If the module has syntax errors, we skip code generation.
+        if (not mod_targ.has_syntax_errors) and (not no_cgen):
+            if settings.predynamo_pass and PreDynamoPass not in py_code_gen:
+                py_code_gen.insert(0, PreDynamoPass)
             self.run_schedule(mod=mod_targ, passes=py_code_gen)
         return mod_targ
 
@@ -137,8 +147,6 @@ class JacProgram:
         """Convert a Jac file to an AST."""
         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)
         for mod in self.mod.hub.values():
             DefUsePass(mod, prog=self)
         return mod_targ

jaclang/compiler/tests/fixtures/jac_import_py_files.py

@@ -0,0 +1,4 @@
+import python_module
+import jac_module
+
+print("This is main test file for jac import of python files")

jaclang/compiler/tests/fixtures/jac_module.jac

@@ -0,0 +1,3 @@
+with entry {
+    print("Hello from Jac module!");
+}

jaclang/compiler/tests/fixtures/multiple_syntax_errors.jac

@@ -0,0 +1,10 @@
+
+obj Foo {
+    has bar: int = 42;
+}
+
+with entry {
+    foo = Foo(;
+    func(foo bar)
+    foo.bar;
+}

jaclang/compiler/tests/fixtures/python_module.py

@@ -0,0 +1 @@
+print("Hello from Python module!")

jaclang/compiler/tests/test_importer.py

@@ -1,6 +1,7 @@
 """Tests for Jac Loader."""
 
 import io
+import os
 import sys
 
 from jaclang import JacMachine as Jac
@@ -8,6 +9,7 @@ from jaclang.cli import cli
 from jaclang.compiler.program import JacProgram
 from jaclang.runtimelib.machine import JacMachineInterface
 from jaclang.utils.test import TestCase
+from jaclang.settings import settings
 
 
 class TestLoader(TestCase):
@@ -128,3 +130,40 @@ class TestLoader(TestCase):
         self.assertIn("Helper function called", stdout_value)
         self.assertIn("Tool function executed", stdout_value)
         self.assertIn("pkg_import_lib_py.glob_var_lib", stdout_value)
+    
+    def test_jac_import_py_files(self) -> None:
+        """Test importing Python files using Jac import system."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        os.environ["JAC_PYFILE_RAISE"] = "True"
+        settings.load_env_vars()
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(os.path.dirname(self.fixture_abs_path("jac_import_py_files.py")))
+            Jac.set_base_path(self.fixture_abs_path("jac_import_py_files.py"))
+            JacMachineInterface.attach_program(
+            program:=JacProgram(),
+            )
+            Jac.jac_import("jac_import_py_files", base_path=self.fixture_abs_path("jac_import_py_files.py"), lng="py")
+            cli.run(self.fixture_abs_path("jac_import_py_files.py"))
+            sys.stdout = sys.__stdout__
+            stdout_value = captured_output.getvalue()
+            self.assertIn("This is main test file for jac import of python files", stdout_value)
+            self.assertIn("python_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
+            self.assertIn("jac_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
+            os.environ["JAC_PYFILE_RAISE"] = "false"
+            settings.load_env_vars()
+            os.chdir(os.path.dirname(self.fixture_abs_path("jac_import_py_files.py")))
+            Jac.set_base_path(self.fixture_abs_path("jac_import_py_files.py"))
+            JacMachineInterface.attach_program(
+            program:=JacProgram(),
+            )
+            Jac.jac_import("jac_import_py_files", base_path=self.fixture_abs_path("jac_import_py_files.py"), lng="py")
+            cli.run(self.fixture_abs_path("jac_import_py_files.py"))
+            sys.stdout = sys.__stdout__
+            stdout_value = captured_output.getvalue()
+            self.assertIn("This is main test file for jac import of python files", stdout_value)
+            self.assertNotIn("python_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
+            self.assertNotIn("jac_module <jaclang.compiler.unitree.Module object", str(program.mod.hub))
+        finally:
+            os.chdir(original_cwd)

jaclang/compiler/tests/test_parser.py

@@ -179,5 +179,54 @@ class TestLarkParser(TestCaseMicroSuite):
         prog.compile(self.fixture_abs_path("codegentext.jac"))
         self.assertFalse(prog.errors_had)
 
+    def test_param_syntax(self) -> None:
+        """Parse param syntax jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        prog = JacProgram()
+        prog.compile(self.lang_fixture_abs_path("params/param_syntax_err.jac"))
+        sys.stdout = sys.__stdout__
+        self.assertEqual(len(prog.errors_had), 8)
+
+    def test_multiple_syntax_errors(self) -> None:
+        """Parse param syntax jac file."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        prog = JacProgram()
+        prog.compile(self.fixture_abs_path("multiple_syntax_errors.jac"))
+        sys.stdout = sys.__stdout__
+        self.assertEqual(len(prog.errors_had), 3)
+        expected_errors = [
+            """
+            Missing RPAREN
+                with entry {
+                    foo = Foo(;
+                              ^
+                    func(foo bar)
+                    foo.bar;
+            """,
+            """
+            Missing COMMA
+                with entry {
+                    foo = Foo(;
+                    func(foo bar)
+                             ^^^
+                    foo.bar;
+                }
+            """,
+            """
+            Missing SEMI
+                    foo = Foo(;
+                    func(foo bar)
+                    foo.bar;
+                    ^^^
+                }
+            """
+        ]
+        for idx, alrt in enumerate(prog.errors_had):
+            pretty = alrt.pretty_print()
+            for line in expected_errors[idx].strip().split("\n"):
+                line = line.strip()
+                self.assertIn(line, pretty)
 
 TestLarkParser.self_attach_micro_tests()

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