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

jaclang/compiler/program.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import ast as py_ast
 import marshal
 import types
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.parser import JacParser
@@ -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,
 )
@@ -34,8 +33,12 @@ from jaclang.compiler.passes.tool import (
     JacFormatPass,
 )
 from jaclang.runtimelib.utils import read_file_with_encoding
+from jaclang.settings import settings
 from jaclang.utils.log import logging
 
+if TYPE_CHECKING:
+    from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
+
 
 logger = logging.getLogger(__name__)
 
@@ -45,7 +48,6 @@ ir_gen_sched = [
     DefUsePass,
     SemDefMatchPass,
     CFGBuildPass,
-    InheritancePass,
 ]
 type_check_sched: list = [
     TypeCheckPass,
@@ -67,6 +69,15 @@ 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."""
+        from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
+
+        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 +131,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 +151,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()