jaclang 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -94,6 +94,8 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
                 part_str = self.format_doc_ir(
                     part, indent_level, current_line_budget, is_broken
                 )
+                if part_str.startswith("\n"):
+                    result = result.rstrip(" ")
                 result += part_str
 
                 if "\n" in part_str:

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

@@ -0,0 +1,14 @@
+obj Anchor(ArchetypeProtocol) {
+    static def on_entry(cls: type, triggers: list[type]);
+    static def on_exit(cls: type, triggers: list[type]);
+    def make_public_ro;
+    def make_public_rw;
+    def make_private;
+    def is_public_ro -> bool;
+    def is_public_rw -> bool;
+    def is_private -> bool;
+    def is_readable(caller_id: UUID) -> bool;
+    def is_writable(caller_id: UUID) -> bool;
+    def give_access(caller_id: UUID, read_write: bool = False);
+    def revoke_access(caller_id: UUID);
+}

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/triple_quoted_string.jac

@@ -1,6 +1,7 @@
 with entry {
-    triple_quoted_string = """This is a triple quoted string.
-    It can span multiple lines.
-    It can contain any number of quotes or apostrophes.
-    """;
+    triple_quoted_string =
+        """This is a triple quoted string.
+        It can span multiple lines.
+        It can contain any number of quotes or apostrophes.
+        """;
 }

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

@@ -0,0 +1,6 @@
+import from datetime { datetime }
+import from uuid { UUID, uuid4 }
+import from jaclang.compiler.constant { EdgeDir }
+import from jaclang.plugin { Archetype, ArchetypeProtocol, DSFunc, AbsRootHook, hookimpl }
+import math;
+import numpy as np;

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

@@ -10,7 +10,7 @@ edge Checking {}
 
 walker Creator {
     has count: int = 0;
-    
+
     can create with `root | Item entry {
         here ++> Item();
         self.count += 1;
@@ -24,11 +24,11 @@ walker Creator {
 walker Walk {
     has count: int = 0;
     has value: int = 0;
-    
+
     can skip_root with `root entry {
         visit [-->];
     }
-    
+
     can step with Item entry {
         here.value = self.count;
         self.count += 1;

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

@@ -0,0 +1,9 @@
+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);
+    }
+}

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

@@ -51,6 +51,23 @@ class JacFormatPassTests(TestCaseMicroSuite):
             os.path.join(self.fixture_abs_path(""), "simple_walk_fmt.jac"),
         )
 
+    def test_tagbreak(self) -> None:
+        """Tests if the file matches a particular format."""
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "tagbreak.jac"),
+        )
+
+    def test_import_fmt(self) -> None:
+        """Tests if the file matches a particular format."""
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "import_fmt.jac"),
+        )
+
+    def test_archetype(self) -> None:
+        """Tests if the file matches a particular format."""
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "archetype_frmt.jac"),
+        )
     # def test_corelib_fmt(self) -> None:
     #     """Tests if the file matches a particular format."""
     #     self.compare_files(
@@ -99,9 +116,7 @@ class JacFormatPassTests(TestCaseMicroSuite):
         """
         code_gen_pure = JacProgram().compile(self.fixture_abs_path(filename))
         code_gen_format = JacProgram.jac_file_formatter(self.fixture_abs_path(filename))
-        code_gen_jac = JacProgram().compile_from_str(
-            source_str=code_gen_format, file_path=filename
-        )
+        code_gen_jac = JacProgram().compile(use_str=code_gen_format, file_path=filename)
         if "circle_clean_tests.jac" in filename:
             tokens = code_gen_format.split()
             num_test = 0

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

@@ -34,8 +34,8 @@ class JacUnparseTests(TestCaseMicroSuite):
         )
         before = ast3.dump(code_gen_pure.gen.py_ast[0], indent=2)
         x = code_gen_pure.unparse()
-        code_gen_jac = JacProgram().compile_from_str(
-            source_str=x,
+        code_gen_jac = JacProgram().compile(
+            use_str=x,
             file_path=filename,
         )
         after = ast3.dump(code_gen_jac.gen.py_ast[0], indent=2)

jaclang/compiler/program.py

@@ -12,14 +12,12 @@ from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes.main import (
     Alert,
     CFGBuildPass,
-    CompilerMode,
     DeclImplMatchPass,
     DefUsePass,
     InheritancePass,
     JacAnnexPass,
     JacImportDepsPass,
     PyBytecodeGenPass,
-    PyImportDepsPass,
     PyJacAstLinkPass,
     PyastBuildPass,
     PyastGenPass,
@@ -38,6 +36,7 @@ from jaclang.utils.log import logging
 logger = logging.getLogger(__name__)
 
 ir_gen_sched = [
+    SymTabBuildPass,
     DeclImplMatchPass,
     DefUsePass,
     CFGBuildPass,
@@ -63,29 +62,13 @@ class JacProgram:
 
     def get_bytecode(self, full_target: str) -> Optional[types.CodeType]:
         """Get the bytecode for a specific module."""
-        if full_target in self.mod.hub:
+        if full_target in self.mod.hub and self.mod.hub[full_target].gen.py_bytecode:
             codeobj = self.mod.hub[full_target].gen.py_bytecode
             return marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
-        result = self.compile(file_path=full_target, mode=CompilerMode.COMPILE_SINGLE)
+        result = self.compile(file_path=full_target)
         return marshal.loads(result.gen.py_bytecode) if result.gen.py_bytecode else None
 
-    def compile(
-        self,
-        file_path: str,
-        mode: CompilerMode = CompilerMode.COMPILE,
-    ) -> uni.Module:
-        """Convert a Jac file to an AST."""
-        with open(file_path, "r", encoding="utf-8") as file:
-            return self.compile_from_str(
-                source_str=file.read(), file_path=file_path, mode=mode
-            )
-
-    def compile_from_str(
-        self,
-        source_str: str,
-        file_path: str,
-        mode: CompilerMode = CompilerMode.COMPILE,
-    ) -> uni.Module:
+    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"):
@@ -111,54 +94,32 @@ class JacProgram:
         if self.mod.main.stub_only:
             self.mod = uni.ProgramModule(mod)
         self.mod.hub[mod.loc.mod_path] = mod
-        return self.run_pass_schedule(mod_targ=mod, mode=mode)
+        JacAnnexPass(ir_in=mod, prog=self)
+        return mod
 
-    def run_pass_schedule(
-        self,
-        mod_targ: uni.Module,
-        mode: CompilerMode = CompilerMode.COMPILE,
+    def compile(
+        self, file_path: str, use_str: str | None = None, no_cgen: bool = False
     ) -> uni.Module:
         """Convert a Jac file to an AST."""
-        JacAnnexPass(ir_in=mod_targ, prog=self)
-        SymTabBuildPass(ir_in=mod_targ, prog=self)
-        if mode == CompilerMode.PARSE:
-            return mod_targ
-        elif mode in (CompilerMode.COMPILE_SINGLE, CompilerMode.NO_CGEN_SINGLE):
-            self.schedule_runner(mod_targ, mode=mode)
-            return mod_targ
+        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)
+        self.run_schedule(mod=mod_targ, passes=ir_gen_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:
+        """Convert a Jac file to an AST."""
+        mod_targ = self.compile(file_path, use_str)
         JacImportDepsPass(ir_in=mod_targ, prog=self)
-        if len(self.errors_had):
-            return mod_targ
-        SymTabLinkPass(ir_in=mod_targ, prog=self)
         for mod in self.mod.hub.values():
-            self.schedule_runner(mod, mode=CompilerMode.COMPILE)
-        if mode == CompilerMode.COMPILE:
-            return mod_targ
-        PyImportDepsPass(mod_targ, prog=self)
-        SymTabLinkPass(ir_in=mod_targ, prog=self)
+            SymTabLinkPass(ir_in=mod, prog=self)
         for mod in self.mod.hub.values():
             DefUsePass(mod, prog=self)
-        for mod in self.mod.hub.values():
-            self.schedule_runner(mod, mode=CompilerMode.TYPECHECK)
         return mod_targ
 
-    def schedule_runner(
-        self,
-        mod: uni.Module,
-        mode: CompilerMode = CompilerMode.COMPILE,
-    ) -> None:
-        """Run premade passes on the module."""
-        match mode:
-            case CompilerMode.NO_CGEN | CompilerMode.NO_CGEN_SINGLE:
-                passes = ir_gen_sched
-            case CompilerMode.COMPILE | CompilerMode.COMPILE_SINGLE:
-                passes = [*ir_gen_sched, *py_code_gen]
-            case CompilerMode.TYPECHECK:
-                passes = []
-            case _:
-                raise ValueError(f"Invalid mode: {mode}")
-        self.run_schedule(mod, passes)
-
     def run_schedule(
         self,
         mod: uni.Module,

jaclang/compiler/tests/fixtures/pkg_import_lib_py/__init__.py

@@ -1,11 +1,5 @@
-
-
 from jaclang import JacMachineInterface as _
 
-(tool_func,) = _.py_jac_import(
-    target="tools",
-    base_path=__file__,
-    items={"tool_func": None},
-)
+from .tools import tool_func
 
-glob_var_lib = 'pkg_import_lib_py.glob_var_lib'
+glob_var_lib = "pkg_import_lib_py.glob_var_lib"

jaclang/compiler/tests/fixtures/pkg_import_lib_py/sub/__init__.py

@@ -1,7 +1,3 @@
 from jaclang import JacMachineInterface as _
 
-(help_func,) = _.py_jac_import(
-    target=".helper",
-    base_path=__file__,
-    items={"help_func": None},
-)
+from .helper import help_func

jaclang/compiler/tests/test_importer.py

@@ -3,10 +3,10 @@
 import io
 import sys
 
-from jaclang import JacMachineInterface as Jac
+from jaclang import JacMachine as Jac
 from jaclang.cli import cli
 from jaclang.compiler.program import JacProgram
-from jaclang.runtimelib.machine import JacMachineInterface, JacMachine
+from jaclang.runtimelib.machine import JacMachineInterface
 from jaclang.utils.test import TestCase
 
 
@@ -15,29 +15,27 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        mach = JacMachine(self.fixture_abs_path(__file__))
+        Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
-            mach,
             JacProgram(),
         )
-        (h,) = Jac.jac_import(mach, "fixtures.hello_world", base_path=__file__)
+        (h,) = Jac.jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
-        mach = JacMachine(self.fixture_abs_path(__file__))
+        Jac.set_base_path(self.fixture_abs_path(__file__))
         JacMachineInterface.attach_program(
-            mach,
             JacProgram(),
         )
-        Jac.jac_import(mach, "fixtures.hello_world", base_path=__file__)
+        Jac.jac_import("fixtures.hello_world", base_path=__file__)
         self.assertIn(
             "module 'fixtures.hello_world'",
-            str(mach.loaded_modules),
+            str(Jac.loaded_modules),
         )
         self.assertIn(
             "/tests/fixtures/hello_world.jac",
-            str(mach.loaded_modules).replace("\\\\", "/"),
+            str(Jac.loaded_modules).replace("\\\\", "/"),
         )
 
     def test_jac_py_import(self) -> None:
@@ -92,12 +90,11 @@ class TestLoader(TestCase):
         sys.stdout = captured_output
 
         try:
-            mach = JacMachine(self.fixture_abs_path(__file__))
+            Jac.set_base_path(self.fixture_abs_path(__file__))
             JacMachineInterface.attach_program(
-                mach,
                 JacProgram(),
             )
-            Jac.jac_import(mach, module_name, base_path=__file__)
+            Jac.jac_import(module_name, base_path=__file__)
             cli.run(jac_file_path)
 
             # Reset stdout and get the output

jaclang/compiler/unitree.py

@@ -849,15 +849,15 @@ class NameAtom(AtomExpr, EnumBlockStmt):
         return None
 
 
-class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstDocNode):
+class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstAsyncNode, AstDocNode):
     """ArchSpec node type for Jac Ast."""
 
     def __init__(
         self, decorators: Sequence[Expr] | None, is_async: bool = False
     ) -> None:
         self.decorators = decorators
-        self.is_async = is_async
         CodeBlockStmt.__init__(self)
+        AstAsyncNode.__init__(self, is_async=is_async)
 
 
 class MatchPattern(UniNode):
@@ -1777,6 +1777,22 @@ class Ability(
     def is_genai_ability(self) -> bool:
         return isinstance(self.body, FuncCall)
 
+    def get_pos_argc_range(self) -> tuple[int, int]:
+        """Get the range of positional arguments for this ability.
+
+        Returns -1 for maximum number of arguments if there is an unpacked parameter (e.g., *args).
+        """
+        mn, mx = 0, 0
+        if isinstance(self.signature, FuncSignature):
+            for param in self.signature.params:
+                if param.unpack:
+                    if param.unpack == Tok.STAR_MUL:
+                        mx = -1
+                    break
+                mn += 1
+                mx += 1
+        return mn, mx
+
     def py_resolve_name(self) -> str:
         if isinstance(self.name_ref, Name):
             return self.name_ref.value
@@ -1914,12 +1930,10 @@ class EventSignature(WalkerStmtOnlyNode):
         self,
         event: Token,
         arch_tag_info: Optional[Expr],
-        return_type: Optional[Expr],
         kid: Sequence[UniNode],
     ) -> None:
         self.event = event
         self.arch_tag_info = arch_tag_info
-        self.return_type = return_type
         UniNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__init__(self)
 
@@ -1932,14 +1946,10 @@ class EventSignature(WalkerStmtOnlyNode):
                 if self.arch_tag_info
                 else res
             )
-            res = res and self.return_type.normalize(deep) if self.return_type else res
         new_kid: list[UniNode] = [self.gen_token(Tok.KW_WITH)]
         if self.arch_tag_info:
             new_kid.append(self.arch_tag_info)
         new_kid.append(self.event)
-        if self.return_type:
-            new_kid.append(self.gen_token(Tok.RETURN_HINT))
-            new_kid.append(self.return_type)
         self.set_kids(nodes=new_kid)
         return res
 
@@ -3659,10 +3669,12 @@ class FuncCall(Expr):
         params: Sequence[Expr | KWPair] | None,
         genai_call: Optional[FuncCall],
         kid: Sequence[UniNode],
+        body_genai_call: Optional[FuncCall] = None,
     ) -> None:
         self.target = target
         self.params = list(params) if params else []
         self.genai_call = genai_call
+        self.body_genai_call = body_genai_call
         UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
@@ -4578,17 +4590,21 @@ class String(Literal):
             return eval(self.value)
 
         elif self.value.startswith(("'", '"')):
-            repr_str = self.value.encode().decode("unicode_escape")
-            if (
-                (self.value.startswith('"""') and self.value.endswith('"""'))
-                or (self.value.startswith("'''") and self.value.endswith("'''"))
-            ) and not self.find_parent_of_type(FString):
-                return repr_str[3:-3]
             if (not self.find_parent_of_type(FString)) or (
                 not (self.parent and isinstance(self.parent, FString))
             ):
-                return repr_str[1:-1]
-            return repr_str
+                try:
+                    return ast3.literal_eval(self.value)
+                except (ValueError, SyntaxError):
+                    if (
+                        self.value.startswith('"""') and self.value.endswith('"""')
+                    ) or (self.value.startswith("'''") and self.value.endswith("'''")):
+                        return self.value[3:-3]
+                    return self.value[1:-1]
+            try:
+                return ast3.literal_eval(self.value)
+            except (ValueError, SyntaxError):
+                return self.value
         else:
             return self.value
 

jaclang/langserve/__init__.jac

@@ -1 +1 @@
-"""Jac Language Server Protocol implementation."""
+"""Jaclang langserve package."""