jaclang 0.8.7__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()