jaclang 0.5.18__py3-none-any.whl → 0.6.1__py3-none-any.whl

jaclang/compiler/passes/main/pyout_pass.py

@@ -5,7 +5,6 @@ also creates bytecode files from the Python code, and manages the caching of
 relevant files.
 """
 
-import ast as ast3
 import os
 
 
@@ -43,18 +42,17 @@ class PyOutPass(Pass):
                 out_path_pyc
             ) > os.path.getmtime(mod_path):
                 continue
-            self.gen_python(mod, out_path=out_path_py)
-            self.dump_bytecode(mod, mod_path=mod_path, out_path=out_path_pyc)
+            try:
+                self.gen_python(mod, out_path=out_path_py)
+                self.dump_bytecode(mod, mod_path=mod_path, out_path=out_path_pyc)
+            except Exception as e:
+                self.warning(f"Error in generating Python code: {e}", node)
         self.terminate()
 
     def gen_python(self, node: ast.Module, out_path: str) -> None:
         """Generate Python."""
-        try:
-            with open(out_path, "w") as f:
-                f.write(node.gen.py)
-        except Exception as e:
-            print(ast3.dump(node.gen.py_ast[0], indent=2))
-            raise e
+        with open(out_path, "w") as f:
+            f.write(node.gen.py)
 
     def dump_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None:
         """Generate Python."""
@@ -70,14 +68,17 @@ class PyOutPass(Pass):
         """Get output targets."""
         base_path, file_name = os.path.split(node.loc.mod_path)
         gen_path = os.path.join(base_path, Con.JAC_GEN_DIR)
-        os.makedirs(gen_path, exist_ok=True)
-        with open(os.path.join(gen_path, "__init__.py"), "w"):
-            pass
         mod_dir, file_name = os.path.split(node.loc.mod_path)
         mod_dir = mod_dir.replace(base_path, "").lstrip(os.sep)
         base_name, _ = os.path.splitext(file_name)
         out_dir = os.path.join(gen_path, mod_dir)
-        os.makedirs(out_dir, exist_ok=True)
+        try:
+            os.makedirs(gen_path, exist_ok=True)
+            with open(os.path.join(gen_path, "__init__.py"), "w"):
+                pass
+            os.makedirs(out_dir, exist_ok=True)
+        except Exception as e:
+            self.warning(f"Can't create directory {out_dir}: {e}", node)
         out_path_py = os.path.join(out_dir, f"{base_name}.py")
         out_path_pyc = os.path.join(out_dir, f"{base_name}.jbc")
         return node.loc.mod_path, out_path_py, out_path_pyc

jaclang/compiler/passes/main/registry_pass.py

@@ -32,9 +32,14 @@ class RegistryPass(Pass):
         module_dir = os.path.join(
             os.path.abspath(os.path.dirname(node.source.file_path)), Con.JAC_GEN_DIR
         )
-        os.makedirs(module_dir, exist_ok=True)
-        with open(os.path.join(module_dir, f"{module_name}.registry.pkl"), "wb") as f:
-            pickle.dump(node.registry, f)
+        try:
+            os.makedirs(module_dir, exist_ok=True)
+            with open(
+                os.path.join(module_dir, f"{module_name}.registry.pkl"), "wb"
+            ) as f:
+                pickle.dump(node.registry, f)
+        except Exception as e:
+            self.warning(f"Can't save registry for {module_name}: {e}")
         self.modules_visited.pop()
 
     def exit_architype(self, node: ast.Architype) -> None:

jaclang/compiler/passes/main/schedules.py

@@ -7,27 +7,31 @@ from __future__ import annotations
 
 
 from .sub_node_tab_pass import SubNodeTabPass  # noqa: I100
-from .import_pass import ImportPass  # noqa: I100
+from .import_pass import JacImportPass, PyImportPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass  # noqa: I100
 from .def_impl_match_pass import DeclDefMatchPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
 from .pyout_pass import PyOutPass  # noqa: I100
 from .pybc_gen_pass import PyBytecodeGenPass  # noqa: I100
 from .pyast_gen_pass import PyastGenPass  # noqa: I100
+from .pyjac_ast_link_pass import PyJacAstLinkPass  # noqa: I100
 from .type_check_pass import JacTypeCheckPass  # noqa: I100
 from .fuse_typeinfo_pass import FuseTypeInfoPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
+from .access_modifier_pass import AccessCheckPass  # noqa: I100
 
 py_code_gen = [
     SubNodeTabPass,
-    ImportPass,
+    JacImportPass,
+    PyImportPass,
     SymTabBuildPass,
     DeclDefMatchPass,
     DefUsePass,
     RegistryPass,
     PyastGenPass,
+    PyJacAstLinkPass,
     PyBytecodeGenPass,
 ]
 
-py_code_gen_typed = [*py_code_gen, JacTypeCheckPass, FuseTypeInfoPass]
+py_code_gen_typed = [*py_code_gen, JacTypeCheckPass, FuseTypeInfoPass, AccessCheckPass]
 py_compiler = [*py_code_gen, PyOutPass]

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,26 +46,20 @@ 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:
-
             # 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)`.
@@ -78,8 +77,6 @@ class SymTabPass(Pass):
                             fix(i)
 
             fix(node)
-        self.handle_hit_outcome(node)
-        return node.sym_link
 
     def use_lookup(
         self,
@@ -220,9 +217,9 @@ class SymTabBuildPass(SymTabPass):
         else:
             self.cur_sym_tab.append(self.cur_scope().push_scope(name, key_node))
 
-    def pop_scope(self) -> None:
+    def pop_scope(self) -> SymbolTable:
         """Pop scope."""
-        self.cur_sym_tab.pop()
+        return self.cur_sym_tab.pop()
 
     def cur_scope(self) -> SymbolTable:
         """Return current scope."""
@@ -266,7 +263,13 @@ class SymTabBuildPass(SymTabPass):
         mod_path: str,
         is_imported: bool,
         """
-        self.pop_scope()
+        s = self.pop_scope()
+        # If not the main module add all the other modules symbol table
+        # as a child to the current symbol table
+        if node != self.ir:
+            self.cur_scope().kid.append(s)
+            s.parent = self.cur_scope()
+
         if (
             isinstance(node.parent, ast.Module)
             and node
@@ -276,8 +279,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.
@@ -403,8 +405,9 @@ class SymTabBuildPass(SymTabPass):
                     f" not found to include *, or ICE occurred!"
                 )
             else:
-                for v in source.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.
@@ -450,7 +453,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)
 
@@ -504,7 +507,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)
 
@@ -592,7 +595,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,8 @@
 """Test pass module."""
 
+import jaclang.compiler.absyntree as ast
 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 +15,16 @@ 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()))
+
+    def test_import_auto_impl(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(self.fixture_abs_path("autoimpl.jac"), JacImportPass)
+        num_modules = len(state.ir.get_all_sub_nodes(ast.Module))
+        mod_names = [i.name for i in state.ir.get_all_sub_nodes(ast.Module)]
+        self.assertEqual(num_modules, 3)
+        self.assertIn("getme.impl", mod_names)
+        self.assertIn("autoimpl.impl", mod_names)
+        self.assertIn("autoimpl.something.else.impl", mod_names)

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 == ":"
             ):
@@ -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)