jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

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

@@ -16,7 +16,6 @@ obj Memory {
     can save_obj(caller_id: UUID, item: Element);
     can del_obj(caller_id: UUID, item: Element);
     #* Utility Functions *#
-
     can get_object_distribution -> dict;
     can get_mem_size -> float;
 }
@@ -32,7 +31,7 @@ obj ExecutionContext {
 "Global Execution Context, should be monkey patched by the user."
 glob exec_ctx = ExecutionContext();
 
-obj ElementAnchor {
+obj Anchor :ArchitypeProtocol: {
     has ob: object,
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
@@ -41,8 +40,12 @@ obj ElementAnchor {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory;
+        mem: Memory = exec_ctx.memory,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc];
 
+    static can on_entry(cls: type, triggers: list[type]);
+    static can on_exit(cls: type, triggers: list[type]);
     can make_public_ro;
     can make_public_rw;
     can make_private;
@@ -55,15 +58,7 @@ obj ElementAnchor {
     can revoke_access(caller_id: UUID);
 }
 
-obj ObjectAnchor :ElementAnchor, ArchitypeProtocol: {
-    has ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
-
-    static can on_entry(cls: type, triggers: list[type]);
-    static can on_exit(cls: type, triggers: list[type]);
-}
-
-obj NodeAnchor :ObjectAnchor: {
+obj NodeAnchor :Anchor: {
     has edges: dict[EdgeDir, list[Edge]] = {EdgeDir.IN: [], EdgeDir.OUT: []};
 
     can connect_node(nd: Node, edg: Edge) -> Node;
@@ -71,7 +66,7 @@ obj NodeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj EdgeAnchor :ObjectAnchor: {
+obj EdgeAnchor :Anchor: {
     has source: Node = None,
         target: Node = None,
         dir: EdgeDir = None;
@@ -81,7 +76,7 @@ obj EdgeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj WalkerAnchor :ObjectAnchor: {
+obj WalkerAnchor :Anchor: {
     has path: list[Node] = [],
         next: list[Node] = [],
         ignores: list[Node] = [],
@@ -94,27 +89,27 @@ obj WalkerAnchor :ObjectAnchor: {
 }
 
 obj Root :AbsRootHook: {
-    has _jac_: NodeAnchor | None = None;
+    has __jac__: NodeAnchor | None = None;
 
     can postinit {
-        self._jac_ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj GenericEdge :ArchitypeProtocol: {
-    has _jac_: EdgeAnchor | None = None;
+    has __jac__: EdgeAnchor | None = None;
 
     can postinit {
-        self._jac_ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj Master {
-    has _jac_: ElementAnchor | None = None;
+    has __jac__: Anchor | None = None;
     has root_node: Root = Root(Root);
 
     can postinit {
-        self._jac_ = ElementAnchor(self);
+        self.__jac__ = Anchor(self);
     }
 }
 
@@ -204,31 +199,31 @@ obj JacPlugin {
     PRIVATE
 }
 
-:obj:ElementAnchor:can:make_public_ro {
+:obj:Anchor:can:make_public_ro {
     self.__jinfo.access_mode = AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:make_public_rw {
+:obj:Anchor:can:make_public_rw {
     self.__jinfo.access_mode = AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:make_private {
+:obj:Anchor:can:make_private {
     self.__jinfo.access_mode = AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_public_ro -> bool {
+:obj:Anchor:can:is_public_ro -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:is_public_rw -> bool {
+:obj:Anchor:can:is_public_rw -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:is_private -> bool {
+:obj:Anchor:can:is_private -> bool {
     return self.__jinfo.access_mode == AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_readable
+:obj:Anchor:can:is_readable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_read
@@ -236,14 +231,14 @@ obj JacPlugin {
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:is_writable
+:obj:Anchor:can:is_writable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_write
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:give_access
+:obj:Anchor:can:give_access
 (caller_id: UUID, read_write: bool=False) {
     if read_write {
         caller_id |> self.rw_access.add;
@@ -252,13 +247,13 @@ obj JacPlugin {
     }
 }
 
-:obj:ElementAnchor:can:revoke_access
+:obj:Anchor:can:revoke_access
 (caller_id: UUID) {
     caller_id |> self.ro_access.discard;
     caller_id |> self.rw_access.discard;
 }
 
-:obj:ObjectAnchor:can:on_entry
+:obj:Anchor:can:on_entry
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_entry_funcs.append(
@@ -272,7 +267,7 @@ obj JacPlugin {
     return decorator;
 }
 
-:obj:ObjectAnchor:can:on_exit
+:obj:Anchor:can:on_exit
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_exit_funcs.append(
@@ -361,7 +356,7 @@ obj JacPlugin {
 
 :obj:NodeAnchor:can:__call__
 (walk: object) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
     walk(self);
@@ -369,10 +364,10 @@ obj JacPlugin {
 
 :obj:EdgeAnchor:can:__call__
 (walk: EdgeInterface) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
-    walk(self._jac_.target);
+    walk(self.__jac__.target);
 }
 
 :obj:WalkerAnchor:can:__call__
@@ -423,25 +418,25 @@ obj JacPlugin {
 (arch: AT, arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]) -> bool {
     match arch_type {
         case 'obj':
-            arch._jac_ = ObjectAnchor(
+            arch.__jac__ = Anchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'node':
-            arch._jac_ = NodeAnchor(
+            arch.__jac__ = NodeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'edge':
-            arch._jac_ = EdgeAnchor(
+            arch.__jac__ = EdgeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'walker':
-            arch._jac_ = WalkerAnchor(
+            arch.__jac__ = WalkerAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
@@ -464,19 +459,19 @@ obj JacPlugin {
         edg_type = edge_spec[1];
     }
     edg = edg_type(*(edge_spec[2])) if edge_spec[2] else edg_type();
-    edg._jac_.apply_dir(edge_spec[0]);
+    edg.__jac__.apply_dir(edge_spec[0]);
     return edg;
 }
 
 :obj:JacPlugin:can:connect
 (left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {
     edg = JacPlugin.build_edge(edge_spec);
-    left.connect_node(right._jac_, edg._jac_);
+    left.connect_node(right.__jac__, edg.__jac__);
 }
 
 :obj:JacPlugin:can:visit_node
 (walker_obj: Any, expr: Any) -> bool {
-    return walker_obj._jac_.visit_node(expr);
+    return walker_obj.__jac__.visit_node(expr);
 }
 
 glob expected_area = 78.53981633974483;

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

@@ -0,0 +1,27 @@
+can:priv hash(func: Any) {
+    can inner(a: Any) {
+        print(("#" * 20));
+        func(a);
+        print(("#" * 20));
+    }
+    return inner;
+}
+
+can:protect exclaim(func: Any) {
+    can inner(b: Any) {
+        print(("!" * 20));
+        func(b);
+        print(("!" * 20));
+    }
+    return inner;
+}
+
+@hash
+@exclaim
+can greeter(name: Any) {
+    print("Hello, " + name + "!");
+}
+
+with entry {
+    greeter("World");
+}

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

@@ -0,0 +1,13 @@
+class Animal {}
+
+obj Domesticated {}
+
+@print_base_classes
+node Pet :Animal, Domesticated: {}
+
+walker Person :Animal: {}
+
+walker Feeder :Person: {}
+
+@print_base_classes
+walker Zoologist :Feeder: {}

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

@@ -0,0 +1,11 @@
+obj inner_red {
+    has color22: string = 'red',
+        # self
+        doublepoint11: int = 2,
+        doublepoint22: float = 2.0,
+        # self
+        doublepoint33: int = 2,
+        # Comments explaining each attribute
+        # color22: represents the color, set to 'red'
+        point22: int = 20;
+}

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

@@ -0,0 +1,13 @@
+with entry:__main__ {
+    app = App();
+    app.run();
+    # ray.init_window(800, 450, "Hello");
+    # while not ray.window_should_close() {
+    #     ray.begin_drawing();
+    #     ray.clear_background(ray.WHITE);
+    #     ray.draw_text("Hello world", 190, 200, 20, ray.VIOLET);
+    #     ray.end_drawing();
+    # }
+
+    # ray.close_window();
+}

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

@@ -0,0 +1,37 @@
+can star(func: Any) {
+    can inner(x: Any) {
+        print(("*" * 30));
+        func(x);
+        print(("*" * 30));
+    }
+    return inner;
+}
+
+can percent(func: Any) {
+    can inner(y: Any) {
+        print(("%" * 30));
+        func(y);
+        print(("%" * 30));
+    }
+    return inner;
+}
+
+can percent2(func: Any) {
+    can inner(y: Any) {
+        print(("-" * 30));
+        func(y);
+        print(("+" * 30));
+    }
+    return inner;
+}
+
+@star
+@percent
+@percent2
+can printer(msg: Any) {
+    print(msg);
+}
+
+with entry {
+    printer("Hello");
+}

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

@@ -0,0 +1,5 @@
+with entry {
+    <>self = 5;
+    <>self += <>self;
+    print(<>self);
+}

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

@@ -0,0 +1,19 @@
+with entry {
+    long_variable_name_1 = another_long_variable_name_2
+        = yet_another_long_variable_name_3
+        = still_another_long_variable_name_4
+        = yet_still_another_long_variable_name_5
+        = one_more_long_variable_name_6
+        = and_another_long_variable_name_7
+        = final_long_variable_name_8
+        =1.5;
+    result = long_variable_name_1
+        + another_long_variable_name_2
+        * yet_another_long_variable_name_3
+        - still_another_long_variable_name_4
+        / yet_still_another_long_variable_name_5
+        + one_more_long_variable_name_6
+        * and_another_long_variable_name_7
+        - final_long_variable_name_8;
+    print("The result of the ugly calculation is:", result);
+}

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

@@ -0,0 +1,6 @@
+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.
+    """;
+}

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

@@ -102,6 +102,17 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
                 file_path = os.path.join(fixtures_dir, file_name)
                 self.compare_files(file_path)
 
+    def test_general_format_fixtures(self) -> None:
+        """Tests if files in the general fixtures directory do not change after being formatted."""
+        fixtures_dir = os.path.join(self.fixture_abs_path(""), "general_format_checks")
+        fixture_files = os.listdir(fixtures_dir)
+        for file_name in fixture_files:
+            if file_name == "__jac_gen__":
+                continue
+            with self.subTest(file=file_name):
+                file_path = os.path.join(fixtures_dir, file_name)
+                self.compare_files(file_path)
+
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
         code_gen_pure = jac_file_to_pass(

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

@@ -33,47 +33,41 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        try:
-            code_gen_pure = jac_file_to_pass(
-                self.fixture_abs_path(filename),
-                target=PyastGenPass,
-                schedule=without_format,
+        code_gen_pure = jac_file_to_pass(
+            self.fixture_abs_path(filename),
+            target=PyastGenPass,
+            schedule=without_format,
+        )
+        before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
+        x = code_gen_pure.ir.unparse()
+        # print(x)
+        # print(f"Testing {code_gen_pure.ir.name}")
+        # print(code_gen_pure.ir.pp())
+        code_gen_jac = jac_str_to_pass(
+            jac_str=x,
+            file_path=filename,
+            target=PyastGenPass,
+            schedule=without_format,
+        )
+        after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
+        if "circle_clean_tests.jac" in filename:
+            self.assertEqual(
+                len(
+                    [
+                        i
+                        for i in unified_diff(
+                            before.splitlines(), after.splitlines(), n=0
+                        )
+                        if "test" not in i
+                    ]
+                ),
+                5,
             )
-            before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
-            x = code_gen_pure.ir.unparse()
-            # print(x)
-            # print(f"Testing {code_gen_pure.ir.name}")
-            # print(code_gen_pure.ir.pp())
-            code_gen_jac = jac_str_to_pass(
-                jac_str=x,
-                file_path=filename,
-                target=PyastGenPass,
-                schedule=without_format,
+        else:
+            self.assertEqual(
+                len("\n".join(unified_diff(before.splitlines(), after.splitlines()))),
+                0,
             )
-            after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
-            if "circle_clean_tests.jac" in filename:
-                self.assertEqual(
-                    len(
-                        [
-                            i
-                            for i in unified_diff(
-                                before.splitlines(), after.splitlines(), n=0
-                            )
-                            if "test" not in i
-                        ]
-                    ),
-                    5,
-                )
-            else:
-                self.assertEqual(
-                    len(
-                        "\n".join(unified_diff(before.splitlines(), after.splitlines()))
-                    ),
-                    0,
-                )
-
-        except Exception as e:
-            raise e
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/compiler/passes/transform.py

@@ -70,3 +70,7 @@ class Transform(ABC, Generic[T]):
         )
         self.warnings_had.append(alrt)
         self.logger.warning(str(alrt))
+
+    def log_info(self, msg: str) -> None:
+        """Log info."""
+        self.logger.info(msg)

jaclang/compiler/passes/utils/mypy_ast_build.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import ast
 import os
+from typing import Callable, TYPE_CHECKING, TextIO
 
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.passes import Pass
@@ -21,13 +22,19 @@ from mypy.build import FileSystemCache
 from mypy.build import Graph
 from mypy.build import ModuleNotFound
 from mypy.build import PRI_INDIRECT
+from mypy.build import Plugin
+from mypy.build import SearchPaths
 from mypy.build import compute_search_paths
 from mypy.build import find_module_simple
+from mypy.build import find_module_with_reason
 from mypy.build import load_plugins
 from mypy.build import process_graph
 from mypy.options import Options
 from mypy.semanal_main import semantic_analysis_for_scc
 
+if TYPE_CHECKING:
+    from mypy.report import Reports  # Avoid unconditional slow import
+
 
 mypy_to_jac_node_map: dict[
     tuple[int, int | None, int | None, int | None], list[AstNode]
@@ -37,6 +44,43 @@ mypy_to_jac_node_map: dict[
 class BuildManager(myb.BuildManager):
     """Overrides to mypy build manager for direct AST pass through."""
 
+    def __init__(
+        self,
+        data_dir: str,
+        search_paths: SearchPaths,
+        ignore_prefix: str,
+        source_set: BuildSourceSet,
+        reports: Reports | None,
+        options: Options,
+        version_id: str,
+        plugin: Plugin,
+        plugins_snapshot: dict[str, str],
+        errors: Errors,
+        flush_errors: Callable[[str | None, list[str], bool], None],
+        fscache: FileSystemCache,
+        stdout: TextIO,
+        stderr: TextIO,
+    ) -> None:
+        """Override mypy BuildManager constructor to initialize jac related map."""
+        global mypy_to_jac_node_map
+        super().__init__(
+            data_dir,
+            search_paths,
+            ignore_prefix,
+            source_set,
+            reports,
+            options,
+            version_id,
+            plugin,
+            plugins_snapshot,
+            errors,
+            flush_errors,
+            fscache,
+            stdout,
+            stderr,
+        )
+        mypy_to_jac_node_map = {}
+
     def parse_file(
         self,
         id: str,
@@ -664,6 +708,7 @@ __all__ = [
     "BuildSource",
     "BuildSourceSet",
     "FileSystemCache",
+    "find_module_with_reason",
     "compute_search_paths",
     "load_graph",
     "load_plugins",

jaclang/compiler/semtable.py

@@ -6,14 +6,24 @@ semantic information.
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import jaclang.compiler.absyntree as ast
 
 
 class SemInfo:
     """Semantic information class."""
 
-    def __init__(self, name: str, type: Optional[str] = None, semstr: str = "") -> None:
+    def __init__(
+        self,
+        node: ast.AstNode,
+        name: str,
+        type: Optional[str] = None,
+        semstr: str = "",
+    ) -> None:
         """Initialize the class."""
+        self.node = node
         self.name = name
         self.type = type
         self.semstr = semstr
@@ -22,6 +32,17 @@ class SemInfo:
         """Return the string representation of the class."""
         return f"{self.semstr} ({self.type}) ({self.name})"
 
+    def get_children(
+        self, sem_registry: SemRegistry, filter: Optional[type[ast.AstNode]] = None
+    ) -> list[SemInfo]:
+        """Get the children of the SemInfo."""
+        scope, _ = sem_registry.lookup(name=self.name)
+        self_scope = str(scope) + f".{self.name}({self.type})"
+        _, children = sem_registry.lookup(scope=SemScope.get_scope_from_str(self_scope))
+        if filter and children and isinstance(children, list):
+            return [i for i in children if isinstance(i.node, filter)]
+        return children if children and isinstance(children, list) else []
+
 
 class SemScope:
     """Scope class."""
@@ -38,7 +59,8 @@ class SemScope:
         """Return the string representation of the class."""
         if self.parent:
             return f"{self.parent}.{self.scope}({self.type})"
-        return f"{self.scope}({self.type})"
+        else:
+            return f"{self.scope}({self.type})"
 
     def __repr__(self) -> str:
         """Return the string representation of the class."""
@@ -57,7 +79,7 @@ class SemScope:
 
     @property
     def as_type_str(self) -> Optional[str]:
-        """Return the type string representation of the SemsScope."""
+        """Return the type string representation of the SemScope."""
         if self.type not in ["class", "node", "obj"]:
             return None
         type_str = self.scope
@@ -127,9 +149,11 @@ class SemRegistry:
                 break
         return i
 
-    def pp(self) -> None:
+    def pp(self) -> str:
         """Pretty print the registry."""
+        ret_str = ""
         for k, v in self.registry.items():
-            print(k)
+            ret_str += f"{k}\n"
             for i in v:
-                print(f"  {i.name} {i.type} {i.semstr}")
+                ret_str += f"  {i.name} {i.type} {i.semstr}\n"
+        return ret_str