jaclang 0.7.13__py3-none-any.whl → 0.7.16__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;
 }

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/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

jaclang/compiler/tests/test_importer.py

@@ -5,6 +5,7 @@ import sys
 
 from jaclang import jac_import
 from jaclang.cli import cli
+from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.utils.test import TestCase
 
 
@@ -17,13 +18,15 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
+        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
         (h,) = 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."""
+        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
         jac_import("fixtures.hello_world", base_path=__file__)
-        self.assertIn("module 'hello_world'", str(sys.modules))
+        self.assertIn("module 'fixtures.hello_world'", str(sys.modules))
         self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))
 
     def test_jac_py_import(self) -> None:
@@ -39,11 +42,15 @@ class TestLoader(TestCase):
             stdout_value,
         )
 
-    def test_package_import(self) -> None:
-        """Test package import."""
+    def test_jac_py_import_auto(self) -> None:
+        """Basic test for pass."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.run(self.fixture_abs_path("../../../tests/fixtures/package_import.jac"))
+        cli.run(self.fixture_abs_path("../../../tests/fixtures/jp_importer_auto.jac"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual("package is imported successfully!\n", stdout_value)
+        self.assertIn("Hello World!", stdout_value)
+        self.assertIn(
+            "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
+            stdout_value,
+        )