jaclang 0.5.17__py3-none-any.whl → 0.6.0__py3-none-any.whl

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -11,7 +11,7 @@ from typing import Optional, Sequence
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
-from jaclang.compiler.symtable import Symbol, SymbolTable
+from jaclang.compiler.symtable import Symbol, SymbolAccess, SymbolTable
 
 
 class SymTabPass(Pass):
@@ -30,10 +30,15 @@ class SymTabPass(Pass):
             return True
         return result
 
+    def inherit_sym_tab(self, scope: SymbolTable, sym_tab: SymbolTable) -> None:
+        """Inherit symbol table."""
+        for i in sym_tab.tab.values():
+            self.def_insert(i.decl, access_spec=i.access, table_override=scope)
+
     def def_insert(
         self,
         node: ast.AstSymbolNode,
-        access_spec: Optional[ast.AstAccessNode] = None,
+        access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
         single_decl: Optional[str] = None,
         table_override: Optional[SymbolTable] = None,
     ) -> Optional[Symbol]:
@@ -41,38 +46,37 @@ class SymTabPass(Pass):
         table = table_override if table_override else node.sym_tab
         if self.seen(node) and node.sym_link and table == node.sym_link.parent_tab:
             return node.sym_link
-        if (
-            table
-            and (
-                table.insert(
-                    node=node, single=single_decl is not None, access_spec=access_spec
-                )
+        if table:
+            table.insert(
+                node=node, single=single_decl is not None, access_spec=access_spec
             )
-            and single_decl
-        ):
-            # self.already_declared_err(
-            #     name=node.sym_name,
-            #     typ=single_decl if single_decl else "ICE",
-            #     original=collide,
-            # )
-            pass  # TODO: Sort this out at some point
+        self.update_py_ctx_for_def(node)
+        self.handle_hit_outcome(node)
+        return node.sym_link
+
+    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
+        """Update python context for definition."""
         node.py_ctx_func = ast3.Store
         if isinstance(node.sym_name_node, ast.AstSymbolNode):
             node.sym_name_node.py_ctx_func = ast3.Store
         if isinstance(node, (ast.TupleVal, ast.ListVal)) and node.values:
-
-            def fix(item: ast.TupleVal | ast.ListVal) -> None:
-                for i in item.values.items if item.values else []:
-                    if isinstance(i, ast.AstSymbolNode):
-                        i.py_ctx_func = ast3.Store
-                    elif isinstance(i, ast.AtomTrailer):
-                        self.chain_def_insert(self.unwind_atom_trailer(i))
-                    if isinstance(i, (ast.TupleVal, ast.ListVal)):
-                        fix(i)
+            # Handling of UnaryExpr case for item is only necessary for
+            # the generation of Starred nodes in the AST for examples
+            # like `(a, *b) = (1, 2, 3, 4)`.
+            def fix(item: ast.TupleVal | ast.ListVal | ast.UnaryExpr) -> None:
+                if isinstance(item, ast.UnaryExpr):
+                    if isinstance(item.operand, ast.AstSymbolNode):
+                        item.operand.py_ctx_func = ast3.Store
+                elif isinstance(item, (ast.TupleVal, ast.ListVal)):
+                    for i in item.values.items if item.values else []:
+                        if isinstance(i, ast.AstSymbolNode):
+                            i.py_ctx_func = ast3.Store
+                        elif isinstance(i, ast.AtomTrailer):
+                            self.chain_def_insert(self.unwind_atom_trailer(i))
+                        if isinstance(i, (ast.TupleVal, ast.ListVal, ast.UnaryExpr)):
+                            fix(i)
 
             fix(node)
-        self.handle_hit_outcome(node)
-        return node.sym_link
 
     def use_lookup(
         self,
@@ -269,8 +273,7 @@ class SymTabBuildPass(SymTabPass):
             ]
             and node.sym_tab
         ):
-            for v in node.sym_tab.tab.values():
-                self.def_insert(v.decl, table_override=self.cur_scope())
+            self.inherit_sym_tab(scope=self.cur_scope(), sym_tab=node.sym_tab)
 
     def enter_global_vars(self, node: ast.GlobalVars) -> None:
         """Sub objects.
@@ -381,17 +384,24 @@ class SymTabBuildPass(SymTabPass):
         is_absorb: bool,
         sub_module: Optional[Module],
         """
-        if node.items:
+        if not node.is_absorb:
             for i in node.items.items:
                 self.def_insert(i, single_decl="import item")
         elif node.is_absorb and node.hint.tag.value == "jac":
-            if not node.paths[0].sub_module or not node.paths[0].sub_module.sym_tab:
+            source = node.items.items[0]
+            if (
+                not isinstance(source, ast.ModulePath)
+                or not source.sub_module
+                or not source.sub_module.sym_tab
+            ):
                 self.error(
-                    f"Module {node.paths[0].path_str} not found to include *, or ICE occurred!"
+                    f"Module {node.from_loc.path_str if node.from_loc else 'from location'}"
+                    f" not found to include *, or ICE occurred!"
                 )
             else:
-                for v in node.paths[0].sub_module.sym_tab.tab.values():
-                    self.def_insert(v.decl, table_override=self.cur_scope())
+                self.inherit_sym_tab(
+                    scope=self.cur_scope(), sym_tab=source.sub_module.sym_tab
+                )
 
     def enter_module_path(self, node: ast.ModulePath) -> None:
         """Sub objects.
@@ -437,7 +447,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional[ArchBlock],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="architype")
+        self.def_insert(node, access_spec=node, single_decl="architype")
         self.push_scope(node.name.value, node)
         self.sync_node_to_scope(node)
 
@@ -491,7 +501,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional[CodeBlock],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="ability")
+        self.def_insert(node, access_spec=node, single_decl="ability")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 
@@ -579,7 +589,7 @@ class SymTabBuildPass(SymTabPass):
         body: Optional['EnumBlock'],
         """
         self.sync_node_to_scope(node)
-        self.def_insert(node, single_decl="enum")
+        self.def_insert(node, access_spec=node, single_decl="enum")
         self.push_scope(node.sym_name, node)
         self.sync_node_to_scope(node)
 

jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -1,7 +1,7 @@
 """Test pass module."""
 
 from jaclang.compiler.compile import jac_file_to_pass
-from jaclang.compiler.passes.main import ImportPass
+from jaclang.compiler.passes.main import JacImportPass
 from jaclang.utils.test import TestCase
 
 
@@ -14,6 +14,6 @@ class ImportPassPassTests(TestCase):
 
     def test_pygen_jac_cli(self) -> None:
         """Basic test for pass."""
-        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), ImportPass)
+        state = jac_file_to_pass(self.fixture_abs_path("base.jac"), JacImportPass)
         self.assertFalse(state.errors_had)
         self.assertIn("56", str(state.ir.to_dict()))

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -117,7 +117,19 @@ class JacFormatPass(Pass):
                 if not node.gen.jac.endswith("\n"):
                     self.emit_ln(node, "")
                 if counter <= len(node.body) - 1:
-                    self.emit_ln(node, "")
+                    if (
+                        isinstance(i, ast.Ability)
+                        and isinstance(node.body[counter], ast.Ability)
+                        and i.gen.jac.endswith(";")
+                        or (
+                            isinstance(i, ast.Architype)
+                            and len(node.body[counter].kid[-1].kid) == 2
+                            and len(node.body[counter - 1].kid[-1].kid) == 2
+                        )
+                    ):
+                        self.emit(node, "")
+                    else:
+                        self.emit_ln(node, "")
             last_element = i
 
     def exit_global_vars(self, node: ast.GlobalVars) -> None:
@@ -274,15 +286,19 @@ class JacFormatPass(Pass):
                         if prev_token and isinstance(prev_token, ast.Ability):
                             self.emit(node, f"{stmt.gen.jac}")
                         else:
-                            self.emit(node, f"{stmt.gen.jac}\n")
+                            self.emit(node, stmt.gen.jac)
+                            if not stmt.gen.jac.endswith("postinit;"):
+                                self.indent_level -= 1
+                                self.emit_ln(node, "")
+                                self.indent_level += 1
                 elif stmt.gen.jac == ",":
                     self.emit(node, f"{stmt.value} ")
                 elif stmt.value == "=":
                     self.emit(node, f" {stmt.value} ")
                 else:
                     self.emit(node, f"{stmt.value}")
-                    prev_token = stmt
-                    continue
+                prev_token = stmt
+                continue
             elif isinstance(stmt, ast.Semi):
                 self.emit(node, stmt.gen.jac)
             elif isinstance(prev_token, (ast.HasVar, ast.ArchHas)) and not isinstance(
@@ -293,14 +309,28 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.indent_level += 1
                 self.emit(node, stmt.gen.jac)
-            elif isinstance(prev_token, ast.Ability) and isinstance(stmt, ast.Ability):
+            elif isinstance(prev_token, ast.Ability) and isinstance(
+                stmt, (ast.Ability, ast.AbilityDef)
+            ):
                 if not isinstance(prev_token.kid[-1], ast.CommentToken) and (
-                    prev_token.body and stmt.body
+                    stmt.body and not isinstance(stmt.body, ast.FuncCall)
                 ):
                     self.indent_level -= 1
                     self.emit_ln(node, "")
                     self.indent_level += 1
-                self.emit(node, stmt.gen.jac)
+                    self.emit(node, f"{stmt.gen.jac}")
+                elif stmt.body and isinstance(
+                    stmt.body, (ast.FuncCall, ast.EventSignature)
+                ):
+                    self.indent_level -= 1
+                    self.emit_ln(node, "")
+                    self.indent_level += 1
+                    self.emit(node, stmt.gen.jac)
+                else:
+                    self.indent_level -= 1
+                    self.emit_ln(node, "")
+                    self.indent_level += 1
+                    self.emit(node, f"{stmt.gen.jac}")
             else:
                 if prev_token and prev_token.gen.jac.strip() == "{":
                     self.emit_ln(node, "")
@@ -652,8 +682,6 @@ class JacFormatPass(Pass):
                     else:
                         self.emit(node, f" {i.gen.jac}")
             prev_token = i
-        if isinstance(node.kid[-1], ast.Semi) and not node.gen.jac.endswith("\n"):
-            self.emit_ln(node, "")
 
     def exit_func_signature(self, node: ast.FuncSignature) -> None:
         """Sub objects.
@@ -809,7 +837,9 @@ class JacFormatPass(Pass):
             elif isinstance(i, ast.Token) and i.gen.jac == ":":
                 self.emit(node, f"{i.gen.jac} ")
             else:
-                if start or (prev_token and isinstance(prev_token, ast.String)):
+                if start or (
+                    prev_token and isinstance(prev_token, (ast.String, ast.Name))
+                ):
                     self.emit(node, i.gen.jac)
                     start = False
                 else:
@@ -972,6 +1002,8 @@ class JacFormatPass(Pass):
                         if not j.gen.jac.startswith(":")
                         else self.emit(node, f"{j.gen.jac} ")
                     )
+            elif isinstance(i, ast.Token) and i.gen.jac == ":":
+                self.emit(node, i.gen.jac)
             else:
                 self.emit(node, f" {i.gen.jac}")
         if isinstance(node.kid[-1], ast.CommentToken) and not node.gen.jac.endswith(
@@ -1130,6 +1162,7 @@ class JacFormatPass(Pass):
             node.parent
             and node.parent.parent
             and isinstance(node.parent.parent, (ast.Ability))
+            and node.parent.kid[1].gen.jac != "self.jaseci_sdk = {};\n"
         ):
             self.emit_ln(node, "")
         start = True
@@ -1210,6 +1243,7 @@ class JacFormatPass(Pass):
             node.parent
             and node.parent.parent
             and isinstance(node.parent.parent, (ast.Ability))
+            and (node.parent.kid[1].gen.jac != "prev_info = [];\n")
         ):
             self.emit_ln(node, "")
         start = True
@@ -1309,9 +1343,16 @@ class JacFormatPass(Pass):
                 if i.is_inline:
                     self.emit(node, i.gen.jac)
                 else:
-                    self.emit_ln(node, "")
-                    self.emit_ln(node, "")
-                    self.emit_ln(node, i.gen.jac)
+                    if i.gen.jac not in [
+                        "# Update any new user level buddy schedule",
+                        "# Construct prompt here",
+                    ]:
+                        self.emit_ln(node, "")
+                        self.emit_ln(node, "")
+                        self.emit_ln(node, i.gen.jac)
+                    else:
+                        self.emit_ln(node, "")
+                        self.emit(node, i.gen.jac)
             elif isinstance(i, ast.Token) and (
                 i.name == Tok.KW_LET or i.gen.jac == ":"
             ):
@@ -1443,10 +1484,10 @@ class JacFormatPass(Pass):
         body: Expr,
         """
         out = ""
-        if node.signature.params:
+        if node.signature and node.signature.params:
             self.comma_sep_node_list(node.signature.params)
             out += node.signature.params.gen.jac
-        if node.signature.return_type:
+        if node.signature and node.signature.return_type:
             out += f" -> {node.signature.return_type.gen.jac}"
         self.emit(node, f"with {out} can {node.body.gen.jac}")
 
@@ -1521,14 +1562,29 @@ class JacFormatPass(Pass):
 
         values: Optional[SubNodeList[ExprType]],
         """
-        if node.values is not None:
-            self.comma_sep_node_list(node.values)
-            self.emit(
-                node,
-                f"[{node.values.gen.jac}]",
-            )
-        else:
-            self.emit(node, "[]")
+        line_break_needed = False
+        indented = False
+        for i in node.kid:
+            if isinstance(i, ast.SubNodeList):
+                line_break_needed = self.is_line_break_needed(i.gen.jac, 88)
+                if line_break_needed:
+                    self.emit_ln(node, "")
+                    self.indent_level += 1
+                    indented = True
+                    for j in i.kid:
+                        if j.gen.jac == (","):
+                            self.indent_level -= 1
+                            self.emit(node, f"{j.gen.jac}\n")
+                            self.indent_level += 1
+                        else:
+                            self.emit(node, f"{j.gen.jac}")
+                else:
+                    self.emit(node, f"{i.gen.jac}")
+                if indented:
+                    self.indent_level -= 1
+                    self.emit(node, "\n")
+            else:
+                self.emit(node, i.gen.jac)
 
     def exit_set_val(self, node: ast.ListVal) -> None:
         """Sub objects.
@@ -1745,6 +1801,7 @@ class JacFormatPass(Pass):
                     ast.ElseStmt,
                     ast.SpecialVarRef,
                     ast.ListCompr,
+                    ast.Name,
                 ),
             ):
                 self.emit(node, f" {i.gen.jac}")
@@ -1907,6 +1964,11 @@ class JacFormatPass(Pass):
             node.parent
             and node.parent.parent
             and isinstance(node.parent.parent, (ast.Ability))
+            and (
+                isinstance(node.parent.kid[1], ast.Assignment)
+                and node.parent.kid[1].kid[-1].gen.jac
+                != "# Update any new user level buddy schedule"
+            )
         ):
             self.indent_level -= 1
             self.emit_ln(node, "")

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

@@ -3,6 +3,7 @@
 import ast as ast3
 import os
 import shutil
+from contextlib import suppress
 from difflib import unified_diff
 
 import jaclang.compiler.absyntree as ast
@@ -56,12 +57,14 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         """Set up test."""
         root_dir = self.fixture_abs_path("")
         directories_to_clean = [
-            os.path.join(root_dir, "myca_formatted_code", "__jac_gen__")
+            os.path.join(root_dir, "myca_formatted_code", "__jac_gen__"),
+            os.path.join(root_dir, "genai", "__jac_gen__"),
         ]
 
         for directory in directories_to_clean:
-            if os.path.exists(directory):
-                shutil.rmtree(directory)
+            with suppress(Exception):
+                if os.path.exists(directory):
+                    shutil.rmtree(directory)
         return super().setUp()
 
     def test_jac_file_compr(self) -> None:
@@ -79,15 +82,19 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         fixtures_dir = os.path.join(self.fixture_abs_path(""), "myca_formatted_code")
         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 test_compare_genia_fixtures(self) -> None:
+    def test_compare_genai_fixtures(self) -> None:
         """Tests if files in the genai fixtures directory do not change after being formatted."""
         fixtures_dir = os.path.join(self.fixture_abs_path(""), "genai")
         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)

jaclang/compiler/passes/transform.py

@@ -54,10 +54,12 @@ class Transform(ABC, Generic[T]):
         """Pass Error."""
         alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
         self.errors_had.append(alrt)
+        # print("Error:", str(alrt))
         self.logger.error(str(alrt))
 
     def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
         """Pass Error."""
         alrt = Alert(msg, self.cur_node.loc if not node_override else node_override.loc)
         self.warnings_had.append(alrt)
+        # print("Warning:", str(alrt))
         self.logger.warning(str(alrt))

jaclang/compiler/symtable.py

@@ -46,9 +46,12 @@ class SymbolType(Enum):
 class SymbolInfo:
     """Symbol Info."""
 
-    def __init__(self, typ: str = "NoType") -> None:  # noqa: ANN401
+    def __init__(
+        self, typ: str = "NoType", acc_tag: Optional[SymbolAccess] = None
+    ) -> None:  # noqa: ANN401
         """Initialize."""
         self.typ = typ
+        self.acc_tag: Optional[SymbolAccess] = acc_tag
         self.typ_sym_table: Optional[SymbolTable] = None
 
 
@@ -146,7 +149,7 @@ class SymbolTable:
     def insert(
         self,
         node: ast.AstSymbolNode,
-        access_spec: Optional[ast.AstAccessNode] = None,
+        access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
         single: bool = False,
     ) -> Optional[ast.AstNode]:
         """Set a variable in the symbol table.
@@ -162,7 +165,11 @@ class SymbolTable:
         if node.sym_name not in self.tab:
             self.tab[node.sym_name] = Symbol(
                 defn=node,
-                access=access_spec.access_type if access_spec else SymbolAccess.PUBLIC,
+                access=(
+                    access_spec
+                    if isinstance(access_spec, SymbolAccess)
+                    else access_spec.access_type if access_spec else SymbolAccess.PUBLIC
+                ),
                 parent_tab=self,
             )
         else:

jaclang/compiler/tests/test_importer.py

@@ -38,3 +38,12 @@ class TestLoader(TestCase):
             "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
             stdout_value,
         )
+
+    def test_package_import(self) -> None:
+        """Test package import."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        cli.run(self.fixture_abs_path("../../../tests/fixtures/package_import.jac"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertEqual("package is imported successfully!\n", stdout_value)

jaclang/compiler/workspace.py

@@ -7,8 +7,7 @@ from typing import Optional, Sequence
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_str_to_pass
-from jaclang.compiler.passes.main import DefUsePass
-from jaclang.compiler.passes.main.schedules import py_code_gen_typed
+from jaclang.compiler.passes.main import DefUsePass, schedules
 from jaclang.compiler.passes.transform import Alert
 from jaclang.compiler.symtable import Symbol, SymbolTable
 
@@ -46,11 +45,14 @@ class ModuleInfo:
 class Workspace:
     """Class for managing workspace."""
 
-    def __init__(self, path: str, lazy_parse: bool = False) -> None:
+    def __init__(
+        self, path: str, lazy_parse: bool = False, type_check: bool = False
+    ) -> None:
         """Initialize workspace."""
         self.path = path
         self.modules: dict[str, ModuleInfo] = {}
         self.lazy_parse = lazy_parse
+        self.type_check = type_check
         self.rebuild_workspace()
 
     def rebuild_workspace(self) -> None:
@@ -78,7 +80,12 @@ class Workspace:
             build = jac_str_to_pass(
                 jac_str=source,
                 file_path=file,
-                target=DefUsePass,
+                schedule=(
+                    schedules.py_code_gen_typed
+                    if self.type_check
+                    else schedules.py_code_gen
+                ),
+                target=DefUsePass if not self.type_check else None,
             )
             if not isinstance(build.ir, ast.Module):
                 src = ast.JacSource(source, mod_path=file)
@@ -118,7 +125,12 @@ class Workspace:
         build = jac_str_to_pass(
             jac_str=source,
             file_path=file_path,
-            schedule=py_code_gen_typed,
+            schedule=(
+                schedules.py_code_gen_typed
+                if self.type_check
+                else schedules.py_code_gen
+            ),
+            target=DefUsePass if not self.type_check else None,
         )
         if not isinstance(build.ir, ast.Module):
             src = ast.JacSource(source, mod_path=file_path)
@@ -171,9 +183,7 @@ class Workspace:
                 [
                     i
                     for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
-                    if i.parent
-                    and isinstance(i.parent, ast.Import)
-                    and i.parent.hint.tag.value == "jac"
+                    if i.parent_of_type(ast.Import).hint.tag.value == "jac"
                 ]
                 if mod_ir
                 else []
@@ -184,9 +194,7 @@ class Workspace:
                     i
                     for i in mod_ir.get_all_sub_nodes(ast.ModulePath)
                     if i.loc.mod_path == file_path
-                    and i.parent
-                    and isinstance(i.parent, ast.Import)
-                    and i.parent.hint.tag.value == "jac"
+                    and i.parent_of_type(ast.Import).hint.tag.value == "jac"
                 ]
                 if mod_ir
                 else []