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

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

@@ -1,5 +1,5 @@
 #this file is part of formatter tests and is not meant to be run
- class SemTokManager {
+class SemTokManager {
     """Initialize semantic token manager."""
     def init(self: SemTokManager, ir: uni.Module) -> None {
         self.aaaaastatic_sem_tokens:
@@ -23,25 +23,23 @@ def walrus_example() {
 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)
+        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)
+            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."""
-    );
+    print("""This is a long
+        line of code.""");
 }
 
 
@@ -95,7 +93,7 @@ class ModuleManager {
 
 
 ## expr as item extra space issue
- with entry {
+with entry {
     with open(f"Apple{apple}.txt") as f {
         # Fix syntax highlighting
         print(
@@ -106,7 +104,7 @@ class ModuleManager {
 
 
 def func_with_very_long_params(
-    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: int,
+    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: int,
     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: int,
 ) -> None {
     print(
@@ -132,9 +130,9 @@ def func_with_short_params(a: int, b: int) -> None {
 
 with entry {
     if (
-        node_selected and
-        node_selected.find_parent_of_type(uni.Archetype) or
-        node_selected.find_parent_of_type(uni.ImplDef)
+        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)
@@ -143,27 +141,35 @@ with entry {
         self_symbol = [];
     }
     x = (
-        1222222222 and
-        2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
+        1222222222
+        and 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
     );
     a = 4 if True else 4;
 }
 
 
+import from typing { Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar }
+
+import from jaclang.compiler.constant {
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType,
+}
+
+
 """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)
+        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)
+        isinstance(node_selected, uni.Name)
+        and node_selected.parent
+        and isinstance(node_selected.parent, uni.ModulePath)
     ) {
         spec = node_selected.parent.parent.abs_path;
     }
@@ -171,8 +177,108 @@ def gen_diagnostics(
 
 
 @decorator
-def x() { }
+def x() {
+    assert gg == 7;
+}
 
 
 @decorator()
 class KK {}
+
+
+# kkk
+import pygame, random, math;
+
+
+# fff
+with entry {
+    # gg
+    a = 9;
+}
+
+
+# kkk
+class X {}
+
+
+# comment
+@decorator
+def xxx() { }
+
+
+# ddd
+glob a = 7;
+def get_node_info(self: JacLangServer, sym_node: uni.AstSymbolNode) -> Optional[str] {
+    try {
+        if isinstance(sym_node, uni.NameAtom) {
+            sym_node = sym_node.name_of;
+        }
+        access = (sym_node.sym.access.value + ' ') if sym_node.sym else None;
+        node_info = f"'('{(access if access else '')}{sym_node.sym_category.value}') '{sym_node.sym_name}";
+        if sym_node.name_spec.clean_type {
+            node_info += f"': '{sym_node.name_spec.clean_type}";
+        }
+        if (
+            isinstance(sym_node, uni.AstSymbolNode)
+            and isinstance(sym_node.name_spec.type, ClassType)
+        ) {
+            node_info += f"': '{sym_node.name_spec.type.shared.class_name}";
+        }
+        if (isinstance(sym_node, uni.AstDocNode) and sym_node.doc) {
+            node_info += f"'\n'{sym_node.doc.value}";
+        }
+        if (isinstance(sym_node, uni.Ability) and sym_node.signature) {
+            node_info += f"'\n'{sym_node.signature.unparse()}";
+        }
+    } except AttributeError as e {
+        self.log_warning(f"'Attribute error when accessing node attributes: '{e}");
+    }
+    return node_info.strip();
+}
+
+
+class foo {
+    """Get information about a node."""
+    def get_node_info(
+        self: JacLangServer, sym_node: uni.AstSymbolNode
+    ) -> Optional[str] {
+        if isinstance(sym_node, uni.AstVarNode) {
+            var_name = sym_node.name;
+            var_type = sym_node.var_type if sym_node.var_type else 'unknown';
+            return f" 'Variable: ' {var_name} ', Type: ' {var_type} ";
+        } elif isinstance(sym_node, uni.AstFuncNode) {
+            func_name = sym_node.name;
+            params = ', '.join(
+                [f" {p.name} ': ' {p.param_type} " for p in sym_node.params]
+            );
+            return f" 'Function: ' {func_name} '(' {params} ')' ";
+        }
+    }
+}
+
+
+def x3() {
+    if dest_type.is_class_instance() and src_type.is_class_instance() {
+        print("x");
+    }
+    if (
+        dest_type.is_class_instance()
+        and src_type.is_class_instance()
+        and src_type.is_class_instance()
+    ) {
+        print("x");
+    }
+    if (dest_type.is_class_instance() and src_type.is_class_instance()) {
+        print("x");
+    }
+}
+
+
+class HH {
+    def test()  -> Optional[str] {
+        a = """!
+hello
+hru
+""";
+    }
+}

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -133,6 +133,8 @@ class JacFormatPassTests(TestCaseMicroSuite):
                     self.assertEqual(tokens[i + 1], "{")
             self.assertEqual(num_test, 3)
             return
+        before = ""
+        after = ""
         try:
             before = ast3.dump(code_gen_pure.gen.py_ast[0], indent=2)
             after = ast3.dump(code_gen_jac.gen.py_ast[0], indent=2)
@@ -151,7 +153,8 @@ class JacFormatPassTests(TestCaseMicroSuite):
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print(add_line_numbers(code_gen_format))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
-            print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
+            if before and after:
+                print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
             raise e
 
 

jaclang/compiler/passes/transform.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import time
 from abc import ABC, abstractmethod
+from threading import Event
 from typing import Generic, Optional, TYPE_CHECKING, Type, TypeVar
 
 from jaclang.compiler.codeinfo import CodeLocInfo
@@ -70,7 +71,9 @@ class Alert:
 class Transform(ABC, Generic[T, R]):
     """Abstract class for IR passes."""
 
-    def __init__(self, ir_in: T, prog: JacProgram) -> None:
+    def __init__(
+        self, ir_in: T, prog: JacProgram, cancel_token: Event | None = None
+    ) -> None:
         """Initialize pass."""
         self.logger = logging.getLogger(self.__class__.__name__)
         self.errors_had: list[Alert] = []
@@ -79,6 +82,7 @@ class Transform(ABC, Generic[T, R]):
         self.prog = prog
         self.time_taken = 0.0
         self.ir_in: T = ir_in
+        self.cancel_token = cancel_token
         self.pre_transform()
         self.ir_out: R = self.timed_transform(ir_in=ir_in)
         self.post_transform()
@@ -136,6 +140,10 @@ class Transform(ABC, Generic[T, R]):
         """Log info."""
         self.logger.info(msg)
 
+    def is_canceled(self) -> bool:
+        """Check if the pass has been canceled."""
+        return self.cancel_token is not None and self.cancel_token.is_set()
+
     def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError:
         """Pass Error."""
         self.log_error(f"ICE: Pass {self.__class__.__name__} - {msg}")

jaclang/compiler/passes/uni_pass.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from threading import Event
 from typing import Optional, TYPE_CHECKING, Type, TypeVar
 
 import jaclang.compiler.unitree as uni
@@ -21,11 +22,12 @@ class UniPass(Transform[uni.Module, uni.Module]):
         self,
         ir_in: uni.Module,
         prog: JacProgram,
+        cancel_token: Event | None = None,
     ) -> None:
         """Initialize parser."""
         self.term_signal = False
         self.prune_signal = False
-        Transform.__init__(self, ir_in, prog)
+        Transform.__init__(self, ir_in, prog, cancel_token=cancel_token)
 
     def before_pass(self) -> None:
         """Run once before pass."""
@@ -43,10 +45,6 @@ class UniPass(Transform[uni.Module, uni.Module]):
         if hasattr(self, f"exit_{pascal_to_snake(type(node).__name__)}"):
             getattr(self, f"exit_{pascal_to_snake(type(node).__name__)}")(node)
 
-    def terminate(self) -> None:
-        """Terminate traversal."""
-        self.term_signal = True
-
     def prune(self) -> None:
         """Prune traversal."""
         self.prune_signal = True
@@ -120,7 +118,7 @@ class UniPass(Transform[uni.Module, uni.Module]):
 
     def traverse(self, node: uni.UniNode) -> uni.UniNode:
         """Traverse tree."""
-        if self.term_signal:
+        if self.is_canceled():
             return node
         self.cur_node = node
         self.enter_node(node)
@@ -131,7 +129,7 @@ class UniPass(Transform[uni.Module, uni.Module]):
         else:
             self.prune_signal = False
         self.cur_node = node
-        if self.term_signal:
+        if self.is_canceled():
             return node
         self.exit_node(node)
         return node

jaclang/compiler/program.py

@@ -5,13 +5,14 @@ from __future__ import annotations
 import ast as py_ast
 import marshal
 import types
-from typing import Optional
+from threading import Event
+from typing import Optional, TYPE_CHECKING
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.parser import JacParser
+from jaclang.compiler.passes.ecmascript import EsastGenPass
 from jaclang.compiler.passes.main import (
     Alert,
-    BinderPass,
     CFGBuildPass,
     DeclImplMatchPass,
     DefUsePass,
@@ -32,13 +33,11 @@ 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
 
-
-logger = logging.getLogger(__name__)
+if TYPE_CHECKING:
+    from jaclang.compiler.type_system.type_evaluator import TypeEvaluator
 
 ir_gen_sched = [
     SymTabBuildPass,
@@ -51,6 +50,7 @@ type_check_sched: list = [
     TypeCheckPass,
 ]
 py_code_gen = [
+    EsastGenPass,
     PyastGenPass,
     PyJacAstLinkPass,
     PyBytecodeGenPass,
@@ -61,7 +61,10 @@ format_sched = [FuseCommentsPass, DocIRGenPass, JacFormatPass]
 class JacProgram:
     """JacProgram to handle the Jac program-related functionalities."""
 
-    def __init__(self, main_mod: Optional[uni.ProgramModule] = None) -> None:
+    def __init__(
+        self,
+        main_mod: Optional[uni.ProgramModule] = None,
+    ) -> None:
         """Initialize the JacProgram object."""
         self.mod: uni.ProgramModule = main_mod if main_mod else uni.ProgramModule()
         self.py_raise_map: dict[str, str] = {}
@@ -71,6 +74,8 @@ class JacProgram:
 
     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
@@ -83,7 +88,9 @@ class JacProgram:
         result = self.compile(file_path=full_target)
         return marshal.loads(result.gen.py_bytecode) if result.gen.py_bytecode else None
 
-    def parse_str(self, source_str: str, file_path: str) -> uni.Module:
+    def parse_str(
+        self, source_str: str, file_path: str, cancel_token: Event | None = None
+    ) -> uni.Module:
         """Convert a Jac file to an AST."""
         had_error = False
         if file_path.endswith(".py") or file_path.endswith(".pyi"):
@@ -94,6 +101,7 @@ class JacProgram:
                     orig_src=uni.Source(source_str, mod_path=file_path),
                 ),
                 prog=self,
+                cancel_token=cancel_token,
             )
             had_error = len(py_ast_ret.errors_had) > 0
             mod = py_ast_ret.ir_out
@@ -120,25 +128,23 @@ class JacProgram:
         # options in it.
         no_cgen: bool = False,
         type_check: bool = False,
+        cancel_token: Event | None = None,
     ) -> 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)
+        mod_targ = self.parse_str(keep_str, file_path, cancel_token=cancel_token)
+        self.run_schedule(mod=mod_targ, passes=ir_gen_sched, cancel_token=cancel_token)
         if type_check:
-            self.run_schedule(mod=mod_targ, passes=type_check_sched)
+            self.run_schedule(
+                mod=mod_targ, passes=type_check_sched, cancel_token=cancel_token
+            )
         # 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
-
-    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)
+            self.run_schedule(
+                mod=mod_targ, passes=py_code_gen, cancel_token=cancel_token
+            )
         return mod_targ
 
     def build(
@@ -155,16 +161,11 @@ class JacProgram:
         self,
         mod: uni.Module,
         passes: list[type[Transform[uni.Module, uni.Module]]],
+        cancel_token: Event | None = None,
     ) -> None:
         """Run the passes on the module."""
-        final_pass: Optional[type[Transform[uni.Module, uni.Module]]] = None
         for current_pass in passes:
-            if current_pass == PyBytecodeGenPass:
-                final_pass = current_pass
-                break
-            current_pass(ir_in=mod, prog=self)  # type: ignore
-        if final_pass:
-            final_pass(mod, prog=self)
+            current_pass(ir_in=mod, prog=self, cancel_token=cancel_token)  # type: ignore
 
     @staticmethod
     def jac_file_formatter(file_path: str) -> str:

jaclang/compiler/tests/test_client_codegen.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from jaclang.compiler.program import JacProgram
+
+
+FIXTURE_DIR = Path(__file__).resolve().parent.parent / "passes" / "ecmascript" / "tests" / "fixtures"
+
+
+def test_js_codegen_generates_js_and_manifest() -> None:
+    fixture = FIXTURE_DIR / "client_jsx.jac"
+    prog = JacProgram()
+    module = prog.compile(str(fixture))
+
+    assert module.gen.js.strip(), "Expected JavaScript output for client declarations"
+    assert "function component" in module.gen.js
+    assert "__jacJsx(" in module.gen.js
+
+    # Client Python code should be omitted in js_only mode
+    assert "def component" not in module.gen.py
+
+    # Metadata should be stored in module.gen.client_manifest
+    assert "__jac_client_manifest__" not in module.gen.py
+    manifest = module.gen.client_manifest
+    assert manifest, "Client manifest should be available in module.gen"
+    assert "component" in manifest.exports
+    assert "ButtonProps" in manifest.exports
+    assert "API_URL" in manifest.globals
+
+    # Module.gen.client_manifest should have the metadata
+    assert "component" in module.gen.client_manifest.exports
+    assert "ButtonProps" in module.gen.client_manifest.exports
+    assert "API_URL" in module.gen.client_manifest.globals
+    assert module.gen.client_manifest.params.get("component", []) == []
+    assert "ButtonProps" not in module.gen.client_manifest.params
+
+
+def test_compilation_skips_python_stubs() -> None:
+    fixture = FIXTURE_DIR / "client_jsx.jac"
+    prog = JacProgram()
+    module = prog.compile(str(fixture))
+
+    assert module.gen.js.strip(), "Expected JavaScript output when emitting both"
+    assert "function component" in module.gen.js
+    assert "__jacJsx(" in module.gen.js
+
+    # Client Python definitions are intentionally omitted
+    assert "def component" not in module.gen.py
+    assert "__jac_client__" not in module.gen.py
+    assert "class ButtonProps" not in module.gen.py
+
+    # Manifest data should be in module.gen.client_manifest
+    assert "__jac_client_manifest__" not in module.gen.py
+    manifest = module.gen.client_manifest
+    assert manifest, "Client manifest should be available in module.gen"
+    assert "component" in manifest.exports
+    assert "ButtonProps" in manifest.exports
+    assert "API_URL" in manifest.globals
+
+    # Module.gen.client_manifest should have the metadata
+    assert "component" in module.gen.client_manifest.exports
+    assert "ButtonProps" in module.gen.client_manifest.exports
+    assert "API_URL" in module.gen.client_manifest.globals
+    assert module.gen.client_manifest.params.get("component", []) == []
+
+
+def test_type_to_typeof_conversion() -> None:
+    """Test that type() calls are converted to typeof in JavaScript."""
+    from tempfile import NamedTemporaryFile
+
+    # Create a temporary test file
+    test_code = '''"""Test type() to typeof conversion."""
+
+cl def check_types() {
+    let x = 42;
+    let y = "hello";
+    let z = True;
+
+    let t1 = type(x);
+    let t2 = type(y);
+    let t3 = type(z);
+    let t4 = type("world");
+
+    return t1;
+}
+'''
+
+    with NamedTemporaryFile(mode='w', suffix='.jac', delete=False) as f:
+        f.write(test_code)
+        f.flush()
+
+        prog = JacProgram()
+        module = prog.compile(f.name)
+
+        assert module.gen.js.strip(), "Expected JavaScript output for client code"
+
+        # Verify type() was converted to typeof
+        assert "typeof" in module.gen.js, "type() should be converted to typeof"
+        assert module.gen.js.count("typeof") == 4, "Should have 4 typeof expressions"
+
+        # Verify no type() calls remain
+        assert "type(" not in module.gen.js, "No type() calls should remain in JavaScript"
+
+        # Verify the typeof expressions are correctly formed
+        assert "typeof x" in module.gen.js
+        assert "typeof y" in module.gen.js
+        assert "typeof z" in module.gen.js
+        assert 'typeof "world"' in module.gen.js
+
+        # Clean up
+        import os
+        os.unlink(f.name)

jaclang/compiler/tests/test_importer.py

@@ -17,6 +17,9 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
+        Jac.reset_machine()
+        sys.modules.pop("fixtures", None)
+        sys.modules.pop("fixtures.hello_world", None)
         Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
             JacProgram(),
@@ -26,6 +29,9 @@ class TestLoader(TestCase):
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
+        Jac.reset_machine()
+        sys.modules.pop("fixtures", None)
+        sys.modules.pop("fixtures.hello_world", None)
         Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
             JacProgram(),
@@ -141,29 +147,25 @@ class TestLoader(TestCase):
         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(),
-            )
+            JacMachineInterface.attach_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))
+            self.assertIn("python_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
+            self.assertIn("jac_module <jaclang.compiler.unitree.Module object", str(Jac.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(),
-            )
+            JacMachineInterface.attach_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))
+            self.assertNotIn("python_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
+            self.assertIn("jac_module <jaclang.compiler.unitree.Module object", str(Jac.program.mod.hub))
         finally:
             os.chdir(original_cwd)