jaclang 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

jaclang/jac/passes/ir_pass.py

@@ -0,0 +1,154 @@
+"""Abstract class for IR Passes for Jac."""
+from typing import Optional, TypeVar
+
+import jaclang.jac.absyntree as ast
+from jaclang.jac.transform import Transform
+from jaclang.jac.utils import pascal_to_snake
+
+T = TypeVar("T", bound=ast.AstNode)
+
+
+class Pass(Transform):
+    """Abstract class for IR passes."""
+
+    def __init__(
+        self,
+        mod_path: str,
+        input_ir: ast.AstNode,
+        base_path: str = "",
+        prior: Optional[Transform] = None,
+    ) -> None:
+        """Initialize parser."""
+        self.term_signal = False
+        self.prune_signal = False
+        self.cur_node = input_ir  # tracks current node during traversal
+        Transform.__init__(self, mod_path, input_ir, base_path, prior)
+
+    def before_pass(self) -> None:
+        """Run once before pass."""
+        pass
+
+    def after_pass(self) -> None:
+        """Run once after pass."""
+        pass
+
+    def enter_node(self, node: ast.AstNode) -> None:
+        """Run on entering node."""
+        if hasattr(self, f"enter_{pascal_to_snake(type(node).__name__)}"):
+            getattr(self, f"enter_{pascal_to_snake(type(node).__name__)}")(node)
+        if isinstance(node, ast.Parse) and hasattr(self, f"enter_{node.name}"):
+            getattr(self, f"enter_{node.name}")(node)
+
+    def exit_node(self, node: ast.AstNode) -> None:
+        """Run on exiting node."""
+        if hasattr(self, f"exit_{pascal_to_snake(type(node).__name__)}"):
+            getattr(self, f"exit_{pascal_to_snake(type(node).__name__)}")(node)
+        if isinstance(node, ast.Parse) and hasattr(self, f"exit_{node.name}"):
+            getattr(self, f"exit_{node.name}")(node)
+
+    def terminate(self) -> None:
+        """Terminate traversal."""
+        self.term_signal = True
+
+    def prune(self) -> None:
+        """Prune traversal."""
+        self.prune_signal = True
+
+    def get_all_sub_nodes(
+        self, node: ast.AstNode, typ: type[T], brute_force: bool = False
+    ) -> list[T]:
+        """Get all sub nodes of type."""
+        result = []
+        # Assumes pass built the sub node table
+        if not node:
+            return result
+        elif len(node._sub_node_tab) and not brute_force:
+            result.extend(node._sub_node_tab[typ] if typ in node._sub_node_tab else [])
+        elif len(node.kid):
+            if not brute_force:
+                raise ValueError(f"Node has no sub_node_tab. {node}")
+            # Brute force search
+            else:
+                for i in node.kid:
+                    if isinstance(i, typ):
+                        result.append(i)
+                    result.extend(self.get_all_sub_nodes(i, typ, brute_force))
+        return result
+
+    def recalculate_parents(self, node: ast.AstNode) -> None:
+        """Recalculate parents."""
+        if not node:
+            return
+        for i in node.kid:
+            if i:
+                i.parent = node
+                self.recalculate_parents(i)
+
+    # Transform Implementations
+    # -------------------------
+    def transform(self, ir: ast.AstNode) -> ast.AstNode:
+        """Run pass."""
+        self.before_pass()
+        if not isinstance(ir, ast.AstNode):
+            raise ValueError("Current node is not an AstNode.")
+        self.traverse(ir)
+        self.after_pass()
+        # Checks if self.ir is created during traversal
+        return self.ir if hasattr(self, "ir") else ir
+
+    def traverse(self, node: ast.AstNode) -> ast.AstNode:
+        """Traverse tree."""
+        if self.term_signal:
+            return node
+        self.cur_node = node
+        self.enter_node(node)
+        if not self.prune_signal:
+            for i in node.kid:
+                if i:
+                    self.traverse(i)
+        else:
+            self.prune_signal = False
+        self.cur_node = node
+        self.exit_node(node)
+        return node
+
+    def update_code_loc(self) -> None:
+        """Update code location."""
+        if not isinstance(self.cur_node, ast.AstNode):
+            self.ice("Current node is not an AstNode.")
+        self.cur_line = self.cur_node.line
+        if self.cur_node.mod_link:
+            self.rel_mod_path = self.cur_node.mod_link.rel_mod_path
+
+    def error(self, msg: str) -> None:
+        """Pass Error."""
+        self.update_code_loc()
+        self.log_error(f"{msg}")
+
+    def warning(self, msg: str) -> None:
+        """Pass Error."""
+        self.update_code_loc()
+        self.log_warning(f"{msg}")
+
+    def ice(self, msg: str) -> None:
+        """Pass Error."""
+        if isinstance(self.cur_node, ast.AstNode):
+            self.cur_line = self.cur_node.line
+        self.log_error(f"ICE: Pass {self.__class__.__name__} - {msg}")
+        raise RuntimeError(
+            f"Internal Compiler Error: Pass {self.__class__.__name__} - {msg}"
+        )
+
+
+class PrinterPass(Pass):
+    """Printer Pass for Jac AST."""
+
+    def enter_node(self, node: ast.AstNode) -> None:
+        """Run on entering node."""
+        print("Entering:", node)
+        super().enter_node(node)
+
+    def exit_node(self, node: ast.AstNode) -> None:
+        """Run on exiting node."""
+        super().exit_node(node)
+        print("Exiting:", node)

jaclang/jac/passes/purple/__init__.py

@@ -0,0 +1,17 @@
+"""Collection of purple passes for Jac IR."""
+from jaclang import jac_blue_import
+from jaclang.jac.passes.blue import pass_schedule
+
+
+purple = jac_blue_import("purple_pygen_pass")
+PurplePygenPass = purple.PurplePygenPass  # type: ignore
+
+__all__ = [
+    "PurplePygenPass",
+]
+
+
+pass_schedule = [
+    *pass_schedule[:-1],
+    PurplePygenPass,
+]

jaclang/jac/passes/purple/impl/__init__.py

@@ -0,0 +1 @@
+"""For setuptools to find this dir."""

jaclang/jac/passes/purple/impl/purple_pygen_pass_impl.jac

@@ -0,0 +1,289 @@
+"""First Jac pass bootstrapped in Jac"""
+import:py from jaclang.jac.constant, Constants as C, EdgeDir;
+
+:object:PurplePygenPass:ability:add_element_import
+(arch: str) {
+    (<self>.preamble, f"from jaclang.core import {arch} as _jac_{arch}_")
+        |> <self>.emit_ln_unique;
+}
+
+:object:PurplePygenPass:ability:add_exec_context {
+    (<self>.preamble, f"from jaclang.core import exec_ctx as {C.EXEC_CONTEXT}")
+        |> <self>.emit_ln_unique;
+}
+
+:object:PurplePygenPass:ability:add_edge_directions {
+    (<self>.preamble, f"from jaclang.jac.constant import EdgeDir as {C.EDGE_DIR}")
+        |> <self>.emit_ln_unique;
+}
+
+:object:PurplePygenPass:ability:needs_jac_import {
+    (<self>.preamble, "from jaclang import jac_purple_import as __jac_import__")
+        |> <self>.emit_ln_unique;
+}
+
+"""
+Sub objects.
+
+name: Name,
+arch_type: Token,
+doc: Optional[DocString],
+decorators: Optional["Decorators"],
+access: Optional[Token],
+base_classes: "BaseClasses",
+body: Optional["ArchBlock"],
+"""
+:object:PurplePygenPass:ability:exit_architype
+(nd: ast.Architype) {
+    |> <self>.add_exec_context;
+    if nd.decorators {
+        (nd, nd.decorators.meta["py_code"]) |> <self>.emit_ln;
+    }
+    arch_type=nd.arch_type.name;
+    arch_insert = "";
+    if arch_type == Tok.KW_OBJECT {
+        "Object" |> <self>.add_element_import;
+        arch_insert = C.OBJECT_CLASS;
+    }
+    elif arch_type == Tok.KW_NODE {
+        "Node" |> <self>.add_element_import;
+        arch_insert = C.NODE_CLASS;
+    }
+    elif arch_type == Tok.KW_EDGE {
+        "Edge" |> <self>.add_element_import;
+        arch_insert = C.EDGE_CLASS;
+    }
+    elif arch_type == Tok.KW_WALKER {
+        "Walker" |> <self>.add_element_import;
+        arch_insert = C.WALKER_CLASS;
+    }
+    if nd.base_classes.base_classes |> len {
+        (nd, f"class {nd.name.meta['py_code']}"
+             f"({nd.base_classes.meta['py_code']}, {arch_insert}):")
+            |> <self>.emit_ln;
+    } else {
+        (nd, f"class {nd.name.meta['py_code']}({arch_insert}):") |> <self>.emit_ln;
+    }
+    <self>.indent_level += 1;
+    if nd.doc {
+        (nd, nd.doc.meta["py_code"]) |> <self>.emit_ln; }
+    if nd.body {
+        (nd, nd.body.meta["py_code"]) |> <self>.emit_ln; }
+    else {
+        nd.name.meta["py_code"] |> <self>.decl_def_missing; }
+    <self>.indent_level -= 1;
+}
+
+
+"""Sub objects.
+
+name: Name,
+is_func: bool,
+is_async: bool,
+doc: Optional[DocString],
+decorators: Optional["Decorators"],
+access: Optional[Token],
+signature: Optional["FuncSignature | TypeSpec | EventSignature"],
+body: Optional["CodeBlock"],
+arch_attached: Optional["ArchBlock"] = None,
+"""
+:object:PurplePygenPass:ability:exit_ability
+(nd: ast.Ability) {
+    "Object" |> <self>.add_element_import;
+    if nd.decorators {
+        (nd, nd.decorators.meta["py_code"]) |> <self>.emit_ln;
+    }
+    if nd.signature:>type == ast.EventSignature and nd.arch_attached and
+        nd.signature.event.name == Tok.KW_ENTRY {
+        type_list = nd.signature.arch_tag_info?.meta?["py_code"] ?: "";
+        (nd, f"@{C.OBJECT_CLASS}._jac_on_entry([{type_list.replace('|', ', ')}])") |> <self>.emit_ln;
+    }
+    elif nd.signature:>type == ast.EventSignature and nd.arch_attached and
+        nd.signature.event.name == Tok.KW_EXIT {
+        type_list = nd.signature.arch_tag_info?.meta?["py_code"] ?: "";
+        (nd, f"@{C.OBJECT_CLASS}._jac_on_exit([{type_list.replace('|', ', ')}])") |> <self>.emit_ln;
+    }
+    if nd.signature:>type in [ast.FuncSignature, ast.EventSignature] {
+        if nd.arch_attached and not nd.is_static {
+            (nd, f"def {nd.name.meta['py_code']}(self{nd.signature.meta['py_code']}:")
+                |> <self>.emit_ln;
+        } else {
+            if nd.arch_attached and nd.is_static {
+                (nd, f"@classmethod") |> <self>.emit_ln;
+            }
+            (nd, f"def {nd.name.meta['py_code']}({nd.signature.meta['py_code']}:")
+                |> <self>.emit_ln;
+        }
+    } else {
+        if nd.arch_attached {
+            (nd, f"def {nd.name.meta['py_code']}(self):") |> <self>.emit_ln;
+        } else {
+            (nd, f"def {nd.name.meta['py_code']}():") |> <self>.emit_ln;
+        }
+    }
+    <self>.indent_level += 1;
+    if nd.doc {
+        (nd, nd.doc.meta["py_code"]) |> <self>.emit_ln;
+    }
+    if nd.body {
+        (nd, "try:") |> <self>.emit_ln;
+        <self>.indent_level += 1;
+        (nd, nd.body.meta["py_code"]) |> <self>.emit;
+        <self>.indent_level -= 1;
+        (nd) |> <self>.emit_jac_error_handler;
+    } else {
+        nd.name.meta["py_code"] |> <self>.decl_def_missing;
+    }
+    <self>.indent_level -= 1;
+}
+
+
+"""Sub objects.
+
+event: Token,
+arch_tag_info: Optional["TypeList | TypeSpec"],
+return_type: Optional["TypeSpec"],
+"""
+:object:PurplePygenPass:ability:exit_event_signature
+(nd: ast.EventSignature) {
+    if (nd.parent|>type) == ast.Ability and nd.parent.arch_attached {
+        (nd, ", ") |> <self>.emit;
+    }
+    if nd.arch_tag_info {
+        (nd, f"{C.HERE}: {nd.arch_tag_info.meta['py_code']})")
+            |> <self>.emit;
+    } else {
+        (nd, f"{C.HERE})") |> <self>.emit;
+    }
+    if nd.return_type {
+        (nd, f" -> {nd.return_type.meta['py_code']}") |> <self>.emit;
+    }
+}
+
+
+"""Sub objects.
+
+ctrl: Token,
+"""
+:object:PurplePygenPass:ability:exit_ctrl_stmt
+(nd: ast.CtrlStmt) {
+    if nd.ctrl.name == Tok.KW_SKIP {
+        (nd, "return") |> <self>.emit_ln;
+    } else {
+        <super>.exit_ctrl_stmt(nd);
+    }
+}
+
+
+"""Sub objects.
+
+vis_type: Optional[Token],
+target: ExprType,
+else_body: Optional["ElseStmt"],
+from_walker: bool = False,
+"""
+:object:PurplePygenPass:ability:exit_visit_stmt
+(nd: ast.VisitStmt) {
+    vis_type = nd.vis_type?.value ?: "";
+    loc = f"{'self' if nd.from_walker else C.HERE}";
+    (nd, f"if not {loc}.{C.WALKER_VISIT}({nd.target.meta['py_code']}): " )
+        |> <self>.emit_ln;
+    <self>.indent_level += 1;
+    if nd.else_body {
+        (nd, nd.else_body.body.meta["py_code"]) |> <self>.emit;
+    } else {
+        (nd, 'pass') |> <self>.emit_ln;
+    }
+    <self>.indent_level -= 1;
+}
+
+
+"""Sub objects.
+from_walker: bool = False,
+"""
+:object:PurplePygenPass:ability:exit_disengage_stmt
+(nd: ast.VisitStmt) {
+    loc = f"{'self' if nd.from_walker else C.HERE}";
+    (nd, f"return {loc}.{C.DISENGAGE}()") |> <self>.emit_ln;
+}
+
+
+"""Sub objects.
+
+left: ExprType,
+right: ExprType,
+op: Token,
+"""
+:object:PurplePygenPass:ability:exit_binary_expr
+(nd: ast.BinaryExpr) {
+    if (nd.op|>type) == ast.ConnectOp {
+        (nd, f"{nd.left.meta['py_code']}.{C.CONNECT_NODE}({nd.right.meta['py_code']}, {nd.op.meta['py_code']})")
+            |> <self>.emit;
+    } else {
+        <super>.exit_binary_expr(nd);
+    }
+}
+
+
+"""Sub objects.
+
+filter_type: Optional[ExprType],
+filter_cond: Optional[FilterCompr],
+edge_dir: EdgeDir,
+"""
+:object:PurplePygenPass:ability:exit_edge_op_ref
+(nd: ast.EdgeOpRef) {
+    edge_dir = f"{C.EDGE_DIR}.IN" if nd.edge_dir == EdgeDir.IN
+               else f"{C.EDGE_DIR}.OUT" if nd.edge_dir == EdgeDir.OUT
+               else f"{C.EDGE_DIR}.ANY";
+    if nd.filter_type and nd.filter_cond {
+        (nd, f"[{C.JAC_TMP} for {C.JAC_TMP} in {C.HERE}.{C.EDGES_TO_NODE}({edge_dir})"
+            f" if isinstance({C.JAC_TMP}, {nd.filter_type.meta['py_code']})"
+            f" and {nd.filter_cond.meta['py_code'].replace(C.PATCH, C.JAC_TMP)}]")
+            |> <self>.emit;
+    }
+    elif nd.filter_type {
+        (nd, f"[{C.JAC_TMP} for {C.JAC_TMP} in {C.HERE}.{C.EDGES_TO_NODE}({edge_dir})"
+            f" if isinstance({C.JAC_TMP}, {nd.filter_type.meta['py_code']})]")
+            |> <self>.emit;
+    }
+    else {
+        (nd, f"{C.HERE}.{C.EDGES_TO_NODE}({edge_dir})")
+            |> <self>.emit;
+    }
+}
+
+
+"""Sub objects.
+
+conn_type: Optional[ExprType],
+conn_assign: Optional[AssignmentList],
+edge_dir: EdgeDir,
+"""
+:object:PurplePygenPass:ability:exit_connect_op
+(nd: ast.ConnectOp) {
+    "Edge" |> <self>.add_element_import;
+    |> <self>.add_edge_directions;
+
+    if nd.conn_type {
+        (nd, f"{nd.conn_type.meta['py_code']}.{C.WITH_DIR}({C.EDGE_DIR}.{nd.edge_dir.name}") |> <self>.emit;
+    } else {
+        (nd, f"{C.EDGE_CLASS}().{C.WITH_DIR}({C.EDGE_DIR}.{nd.edge_dir.name}") |> <self>.emit;
+    }
+    if nd.conn_assign {
+        (nd, f", {nd.conn_assign.meta['py_code']})") |> <self>.emit;
+    } else {
+        (nd, ")") |> <self>.emit;
+    }
+}
+
+"""Sub objects.
+
+conn_type: Optional[ExprType],
+conn_assign: Optional[AssignmentList],
+edge_dir: EdgeDir,
+"""
+:object:PurplePygenPass:ability:exit_disconnect_op
+(nd: ast.DisconnectOp) {
+
+}

jaclang/jac/passes/purple/purple_pygen_pass.jac

@@ -0,0 +1,35 @@
+"""First Jac pass bootstrapped in Jac"""
+import:py jaclang.jac.absyntree as ast;
+import:py from jaclang.jac.passes.blue, BluePygenPass;
+import:py from jaclang.core, Object, Node, Edge, Walker;
+import:py from jaclang.jac.lexer, Tokens as Tok;
+
+
+include:jac impl.purple_pygen_pass_impl;
+
+"""
+This pass leverages data spacial lib to provide code
+gen for full Jac language. It is bootstrapped in Jac blue.
+"""
+object PurplePygenPass:BluePygenPass {
+
+    #*
+    These add functions generate necessary imports
+    given code being generated.
+    *#
+    can add_element_import(arch: str);
+    can add_exec_context;
+    can add_edge_directions;
+    can needs_jac_import;
+
+    can exit_architype(nd: ast.Architype);
+    can exit_ability(nd: ast.Ability);
+    can exit_event_signature(nd: ast.EventSignature);
+    can exit_ctrl_stmt(nd: ast.CtrlStmt);
+    can exit_visit_stmt(nd: ast.VisitStmt);
+    can exit_disengage_stmt(nd: ast.DisengageStmt);
+    can exit_binary_expr(nd: ast.BinaryExpr);
+    can exit_edge_op_ref(nd: ast.EdgeOpRef);
+    can exit_connect_op(nd: ast.ConnectOp);
+    can exit_disconnect_op(nd: ast.DisconnectOp);
+}

jaclang/jac/sym_table.py

@@ -0,0 +1,127 @@
+"""Jac Symbol Table."""
+import pprint
+from typing import Optional, TypeVar
+
+
+import jaclang.jac.absyntree as ast
+
+
+class Symbol:
+    """Symbol."""
+
+    def __init__(
+        self,
+        name: str,
+        node: Optional[ast.AstNode] = None,
+    ) -> None:
+        """Initialize."""
+        self.name = name
+        self.node = node
+
+    def pretty_print(self) -> str:
+        """Pretty print the symbol."""
+        return pprint.pformat(vars(self), indent=2)
+
+    def __repr__(self) -> str:
+        """Representation for printing Symbols."""
+        return f"{self.pretty_print()}"
+
+
+T = TypeVar("T", bound=Symbol)
+
+
+class TypedSymbol(Symbol):
+    """Typed Symbol."""
+
+    def __init__(
+        self,
+        name: str,
+        typ: type,
+        node: ast.AstNode,
+        access: Optional[str] = None,
+    ) -> None:
+        """Initialize."""
+        self.typ = typ
+        self.access = access
+        super().__init__(name, node)
+
+
+class DefDeclSymbol(Symbol):
+    """DefDecl Symbol."""
+
+    def __init__(
+        self,
+        name: str,
+        node: Optional[ast.AstNode] = None,
+        other_node: Optional[ast.AstNode] = None,
+        has_def: bool = False,
+        has_decl: bool = False,
+    ) -> None:
+        """Initialize."""
+        self.other_node = other_node
+        self.has_def = has_def
+        self.has_decl = has_decl
+        super().__init__(name, node)
+
+
+class SymbolTable:
+    """Symbol Table.
+
+    Functions as a stack by default, can create a separate table in pass
+    if keeping track of multiple scopes is necessary.
+    """
+
+    def __init__(
+        self,
+        scope_name: str = "",
+        parent: Optional["SymbolTable"] = None,
+    ) -> None:
+        """Initialize."""
+        self.scope_name = scope_name
+        self.parent = parent
+        self.tab: dict = {}
+
+    def lookup(self, name: str, deep: bool = True) -> Optional[T]:
+        """Lookup a variable in the symbol table."""
+        if name in self.tab:
+            return self.tab[name]
+        if deep and self.parent:
+            return self.parent.lookup(name, deep)
+        return None
+
+    def set(self, sym: T, fresh_only: bool = False) -> bool:
+        """Set a variable in the symbol table."""
+        if fresh_only and sym.name in self.tab:
+            return False
+        self.tab[sym.name] = sym
+        return True
+
+    def update(self, sym: T, deep: bool = False) -> bool:
+        """Set a variable in the symbol table."""
+        if sym.name in self.tab:
+            self.tab[sym.name] = T
+            return True
+        elif deep and self.parent:
+            return self.parent.update(sym)
+        return False
+
+    def push(self, scope_name: str = "") -> "SymbolTable":
+        """Push a new scope onto the symbol table."""
+        return SymbolTable(scope_name, self)
+
+    def pop(self) -> "SymbolTable":
+        """Pop the current scope off the symbol table."""
+        return self.parent if self.parent else self
+
+    def pretty_print(self) -> str:
+        """Pretty print the symbol table and return the result as a string."""
+        output = f"Scope: {self.scope_name}\n"
+        output += pprint.pformat(self.tab)
+        if self.parent:
+            output += f"\nParent Scope: {self.parent.scope_name}\n"
+            output += self.parent.pretty_print()
+        return output
+
+    def __repr__(self) -> str:
+        """Return the symbol table as a string."""
+        return self.pretty_print()

jaclang/jac/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for Jac tools."""

jaclang/jac/tests/fixtures/__init__.py

@@ -0,0 +1 @@
+"""Various fixtures for testing"""

jaclang/jac/tests/fixtures/activity.py

@@ -0,0 +1,10 @@
+"""Activity class for testing."""
+
+
+class Activity:
+    """Activity class for testing."""
+
+    def __init__(self, name: str = "basic", duration: int = 4) -> None:
+        """Activity class for testing."""
+        self.name = name
+        self.duration = duration