jaclang 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/jac/passes/blue/blue_pygen_pass.py

@@ -224,6 +224,13 @@ class BluePygenPass(Pass):
         else:
             self.emit(node, node.body.meta["py_code"])
 
+    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None:
+        """Sub objects.
+
+        code: Token,
+        """
+        self.emit_ln(node, node.code.value)
+
     def exit_import(self, node: ast.Import) -> None:
         """Sub objects.
 
@@ -249,6 +256,7 @@ class BluePygenPass(Pass):
                 self.warning(
                     "Includes import * in target module into current namespace."
                 )
+            return
         if not node.items:
             if not node.alias:
                 self.emit_ln(node, f"import {node.path.meta['py_code']}")
@@ -537,6 +545,13 @@ class BluePygenPass(Pass):
         """
         self.emit(node, ".".join([i.meta["py_code"] for i in node.names]))
 
+    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None:
+        """Sub objects.
+
+        archs: list[ArchRef],
+        """
+        self.emit(node, ".".join([i.meta["py_code"] for i in node.archs]))
+
     def exit_func_signature(self, node: ast.FuncSignature) -> None:
         """Sub objects.
 

jaclang/jac/passes/blue/decl_def_match_pass.py

@@ -2,7 +2,7 @@
 import jaclang.jac.absyntree as ast
 from jaclang.jac.passes import Pass
 from jaclang.jac.passes.blue import SubNodeTabPass
-from jaclang.jac.symtable import SymbolTable, SymbolType
+from jaclang.jac.symtable import SymbolHitType, SymbolTable, SymbolType
 
 
 class DeclDefMatchPass(Pass):
@@ -14,38 +14,50 @@ class DeclDefMatchPass(Pass):
         if not self.ir.sym_tab:
             return self.ice("Expected symbol table on node.")
         self.connect_decl_def(self.ir.sym_tab)
-
-    #        self.terminate()
+        self.terminate()
 
     def after_pass(self) -> None:
         """Rebuild sub node table."""
-        self.ir = SubNodeTabPass(mod_path=self.mod_path, input_ir=self.ir).ir
+        self.ir = SubNodeTabPass(
+            prior=self, mod_path=self.mod_path, input_ir=self.ir
+        ).ir
 
     def connect_decl_def(self, sym_tab: SymbolTable) -> None:
         """Connect Decls and Defs."""
-        # print(sym_tab)
         for sym in sym_tab.tab.values():
-            if sym.sym_type in [SymbolType.ABILITY, SymbolType.ARCH]:
-                if isinstance(sym.decl, ast.Ability) and sym.decl.is_abstract:
-                    if sym.defn:
-                        self.error(
-                            f"Abstract ability {sym.name} should not have a definition.",
-                            sym.defn[-1],
+            if sym.sym_type == SymbolType.IMPL:
+                # currently strips the type info from impls
+                arch_refs = [x[3:] for x in sym.name.split(".")]
+                lookup = sym_tab.lookup(arch_refs[0], sym_hit=SymbolHitType.DECL_DEFN)
+                decl_node = lookup.decl if lookup else None
+                for name in arch_refs[1:]:
+                    if decl_node:
+                        lookup = (
+                            decl_node.sym_tab.lookup(
+                                name, sym_hit=SymbolHitType.DECL_DEFN
+                            )
+                            if decl_node.sym_tab
+                            else None
                         )
-                    continue
-                if not sym.decl:
+                        decl_node = lookup.decl if lookup else None
+                    else:
+                        break
+                if not decl_node:
                     self.error(
-                        f"Unable to match implementation {sym.name} to an declaration.",
+                        f"Unable to match implementation {sym.name} to a declaration.",
                         sym.defn[-1],
                     )
-                if not sym.defn:
+                    continue
+                elif isinstance(decl_node, ast.Ability) and decl_node.is_abstract:
                     self.error(
-                        f"Unable to match declaration {sym.name} to an implementation.",
-                        sym.decl,
+                        f"Abstract ability {decl_node.py_resolve_name()} should not have a definition.",
+                        decl_node,
                     )
-                if sym.decl and sym.defn and sym.decl != sym.defn[-1]:
-                    ast.append_node(sym.decl, sym.defn[-1])
-                    sym.decl.body = sym.defn[-1].body  # type: ignore
-                    sym.decl.sym_tab = sym.defn[-1].sym_tab
+                    continue
+                ast.append_node(decl_node, sym.defn[-1].body)  # type: ignore
+                decl_node.body = sym.defn[-1].body  # type: ignore
+                decl_node.sym_tab.tab = sym.defn[-1].sym_tab.tab  # type: ignore
+                sym.decl = decl_node
+
         for i in sym_tab.kid:
             self.connect_decl_def(i)

jaclang/jac/passes/blue/import_pass.py

@@ -26,7 +26,7 @@ class ImportPass(Pass):
                     ast.append_node(i, self.import_module(i, node.mod_path))
                     i.sub_module = i.kid[-1]
                 self.enter_import(i)
-            SubNodeTabPass(mod_path=node.mod_path, input_ir=node)
+            SubNodeTabPass(prior=self, mod_path=node.mod_path, input_ir=node)
 
     def enter_import(self, node: ast.Import) -> None:
         """Sub objects.

jaclang/jac/passes/blue/pyout_pass.py

@@ -1,16 +1,20 @@
 """Connect Decls and Defs in AST."""
+import marshal
 import os
+import traceback
+
 
 import jaclang.jac.absyntree as ast
+from jaclang.jac.constant import Constants as Con
 from jaclang.jac.passes import Pass
+from jaclang.utils.helpers import handle_jac_error
 
 
 class PyOutPass(Pass):
-    """Decls and Def matching pass."""
+    """Python and bytecode file printing pass."""
 
     def before_pass(self) -> None:
         """Before pass."""
-        self.gen_dir = "__jac_gen__"
         return super().before_pass()
 
     def enter_module(self, node: ast.Module) -> None:
@@ -24,16 +28,47 @@ class PyOutPass(Pass):
         is_imported: bool,
         sym_tab: Optional[SymbolTable],
         """
-        if (
-            not os.path.exists(node.mod_path)
-            or "py_code" not in node.meta
-            or not node.meta["py_code"]
-        ):
+        if not (os.path.exists(node.mod_path) and node.meta.get("py_code")):
             return
-        dir_name, file_name = os.path.split(node.mod_path)
-        base_name, _ = os.path.splitext(file_name)
-        file_name = f"{base_name}.py"
-        os.makedirs(os.path.join(dir_name, self.gen_dir), exist_ok=True)
-        out_path = os.path.join(dir_name, self.gen_dir, file_name)
+        mods = [node] + self.get_all_sub_nodes(node, ast.Module)
+        for mod in mods:
+            mod_path, out_path_py, out_path_pyc = self.get_output_targets(mod)
+            if os.path.exists(out_path_py) and os.path.getmtime(
+                out_path_py
+            ) > os.path.getmtime(mod_path):
+                continue
+            self.gen_python(mod, out_path=out_path_py)
+            self.compile_bytecode(mod, mod_path=mod_path, out_path=out_path_pyc)
+        self.terminate()
+
+    def gen_python(self, node: ast.Module, out_path: str) -> None:
+        """Generate Python."""
         with open(out_path, "w") as f:
             f.write(node.meta["py_code"])
+
+    def compile_bytecode(self, node: ast.Module, mod_path: str, out_path: str) -> None:
+        """Generate Python."""
+        try:
+            codeobj = compile(node.meta["py_code"], f"_jac_py_gen ({mod_path})", "exec")
+        except Exception as e:
+            tb = traceback.extract_tb(e.__traceback__)
+            err = handle_jac_error(node.meta["py_code"], e, tb)
+            raise type(e)(str(e) + "\n" + err)
+        with open(out_path, "wb") as f:
+            marshal.dump(codeobj, f)
+
+    def get_output_targets(self, node: ast.Module) -> tuple[str, str, str]:
+        """Get output targets."""
+        base_path, file_name = os.path.split(node.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.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)
+        out_path_py = os.path.join(out_dir, f"{base_name}.py")
+        out_path_pyc = os.path.join(out_dir, f"{base_name}.pyc")
+        return node.mod_path, out_path_py, out_path_pyc