jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -10,6 +10,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
+from jaclang.settings import settings
 
 
 class JacFormatPass(Pass):
@@ -20,7 +21,7 @@ class JacFormatPass(Pass):
         self.comments: list[ast.CommentToken] = []
         self.indent_size = 4
         self.indent_level = 0
-        self.MAX_LINE_LENGTH = 44
+        self.MAX_LINE_LENGTH = int(float(settings.max_line_length) / 2)
 
     def enter_node(self, node: ast.AstNode) -> None:
         """Enter node."""
@@ -49,7 +50,8 @@ class JacFormatPass(Pass):
 
     def emit(self, node: ast.AstNode, s: str, strip_mode: bool = True) -> None:
         """Emit code to node."""
-        node.gen.jac += self.indent_str() + s.replace("\n", "\n" + self.indent_str())
+        indented_str = re.sub(r"\n(?!\n)", f"\n{self.indent_str()}", s)
+        node.gen.jac += self.indent_str() + indented_str
         if "\n" in node.gen.jac:
             if strip_mode:
                 node.gen.jac = node.gen.jac.rstrip(" ")
@@ -129,9 +131,15 @@ class JacFormatPass(Pass):
             else:
                 if isinstance(last_element, ast.Import):
                     self.emit_ln(node, "")
-                self.emit_ln(node, i.gen.jac)
-                if not node.gen.jac.endswith("\n"):
+                if last_element and (
+                    isinstance(i, ast.Architype)
+                    and isinstance(last_element, ast.Architype)
+                    and i.loc.first_line - last_element.loc.last_line == 2
+                    and not node.gen.jac.endswith("\n\n")
+                ):
                     self.emit_ln(node, "")
+                self.emit_ln(node, i.gen.jac)
+
                 if counter <= len(node.body) - 1:
                     if (
                         isinstance(i, ast.Ability)
@@ -142,6 +150,7 @@ class JacFormatPass(Pass):
                             and len(node.body[counter].kid[-1].kid) == 2
                             and len(node.body[counter - 1].kid[-1].kid) == 2
                         )
+                        and node.gen.jac.endswith("\n")
                     ):
                         self.emit(node, "")
                     else:
@@ -212,7 +221,7 @@ class JacFormatPass(Pass):
         items: list[T],
         """
         prev_token = None
-        for i, stmt in enumerate(node.kid):
+        for stmt in node.kid:
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -238,42 +247,18 @@ class JacFormatPass(Pass):
                 if stmt.name == Tok.LBRACE:
                     self.emit(node, f" {stmt.value}")
                 elif stmt.name == Tok.RBRACE:
-                    if self.indent_level > 0:
-                        self.indent_level -= 1
-                    if (stmt.parent and stmt.parent.gen.jac.strip() == "{") or (
-                        stmt.parent
-                        and stmt.parent.parent
-                        and isinstance(
-                            stmt.parent.parent,
-                            (ast.ElseIf, ast.IfStmt, ast.IterForStmt, ast.TryStmt),
-                        )
-                    ):
+                    self.indent_level = max(0, self.indent_level - 1)
+                    if stmt.parent and stmt.parent.gen.jac.strip() == "{":
                         self.emit(node, f"{stmt.value}")
                     else:
-                        next_kid = (
-                            node.kid[i + 1]
-                            if i < (len(node.kid) - 1)
-                            else ast.EmptyToken()
-                        )
-                        if (
-                            isinstance(next_kid, ast.CommentToken)
-                            and next_kid.is_inline
-                        ):
-                            self.emit(node, f" {stmt.value}")
-                        elif not (node.gen.jac).endswith("\n"):
+                        if not node.gen.jac.endswith("\n"):
                             self.emit_ln(node, "")
-                            self.emit(node, f"{stmt.value}")
-                        else:
-                            self.emit(node, f"{stmt.value}")
+                        self.emit(node, f"{stmt.value}")
                 elif isinstance(stmt, ast.CommentToken):
                     if stmt.is_inline:
                         if isinstance(prev_token, ast.Semi) or (
                             isinstance(prev_token, ast.Token)
-                            and prev_token.name
-                            in [
-                                Tok.LBRACE,
-                                Tok.RBRACE,
-                            ]
+                            and prev_token.name in [Tok.LBRACE, Tok.RBRACE]
                         ):
                             self.indent_level -= 1
                             self.emit(node, f" {stmt.gen.jac}")
@@ -297,48 +282,33 @@ class JacFormatPass(Pass):
                             self.emit(node, stmt.gen.jac)
                             if not stmt.gen.jac.endswith("postinit;"):
                                 self.indent_level -= 1
+                                self.emit_ln(stmt, "")
                                 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} ")
+                elif prev_token and prev_token.gen.jac.strip() == "@":
+                    self.emit_ln(node, stmt.value)
                 else:
-                    self.emit(node, f"{stmt.value}")
+                    self.emit(node, f"{stmt.gen.jac}")
                 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(
-                stmt, (ast.HasVar, ast.ArchHas)
+            elif (
+                isinstance(prev_token, (ast.HasVar, ast.ArchHas))
+                and not isinstance(stmt, (ast.HasVar, ast.ArchHas))
+            ) or (
+                isinstance(prev_token, ast.Ability)
+                and isinstance(stmt, (ast.Ability, ast.AbilityDef))
             ):
                 if not isinstance(prev_token.kid[-1], ast.CommentToken):
                     self.indent_level -= 1
                     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, ast.AbilityDef)
-            ):
-                if not isinstance(prev_token.kid[-1], ast.CommentToken) and (
-                    stmt.body and not isinstance(stmt.body, ast.FuncCall)
-                ):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    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, "")
@@ -352,6 +322,7 @@ class JacFormatPass(Pass):
         tag: T,
         """
         start = True
+        prev_token = None
         for i in node.kid:
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
@@ -366,8 +337,13 @@ class JacFormatPass(Pass):
             elif i.gen.jac == ",":
                 self.emit(node, f"{i.gen.jac} ")
             else:
-                if start:
-                    self.emit(node, i.gen.jac)
+                if isinstance(i, ast.Token) and not isinstance(i, ast.BuiltinType):
+                    try:
+                        prev_token = self.token_before(i)
+                    except Exception:
+                        prev_token = None
+                if start or (prev_token and prev_token.gen.jac.strip() == ":"):
+                    self.emit(node, i.gen.jac.strip())
                     start = False
                 else:
                     self.emit(node, f" {i.gen.jac}")
@@ -469,7 +445,7 @@ class JacFormatPass(Pass):
         path: list[Token],
         alias: Optional[Name],
         """
-        self.emit(node, node.path_str)
+        self.emit(node, node.dot_path_str)
         if node.alias:
             self.emit(node, " as " + node.alias.gen.jac)
 
@@ -681,6 +657,8 @@ class JacFormatPass(Pass):
                 self.emit(node, i.gen.jac)
             elif isinstance(i, ast.SubNodeList) and i.gen.jac.startswith("@"):
                 self.emit_ln(node, i.gen.jac)
+            elif isinstance(i, ast.SubTag):
+                self.emit(node, i.gen.jac)
             else:
                 if start:
                     self.emit(node, i.gen.jac)
@@ -763,7 +741,7 @@ class JacFormatPass(Pass):
                             self.indent_level += indent_val
                             indented = True
                     else:
-                        self.emit(node, f"{j.gen.jac.strip()}")
+                        self.emit(node, j.gen.jac.lstrip())
                 if indented:
                     self.indent_level -= indent_val
             else:
@@ -929,6 +907,8 @@ class JacFormatPass(Pass):
         """Check if the length of the current generated code exceeds the max line length."""
         if max_line_length == 0:
             max_line_length = self.MAX_LINE_LENGTH
+        # print(content)
+        # print(len(content))
         return len(content) > max_line_length
 
     def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
@@ -978,6 +958,7 @@ class JacFormatPass(Pass):
                 self.error(
                     f"Binary operator {node.op.value} not supported in bootstrap Jac"
                 )
+        # print(node.gen)
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -1110,6 +1091,9 @@ class JacFormatPass(Pass):
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
                     self.emit(node, f" {i.gen.jac}")
+                elif (tok := self.token_before(i)) and (i.line_no - tok.line_no == 1):
+                    self.emit_ln(node, "")
+                    self.emit(node, i.gen.jac)
                 else:
                     self.emit_ln(node, "")
                     self.emit_ln(node, "")
@@ -1340,38 +1324,96 @@ class JacFormatPass(Pass):
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
+    def handle_long_assignment(self, node: ast.Assignment, kid: ast.AstNode) -> None:
+        """Handle long assignment lines."""
+        parts = re.split(r"(=)", kid.gen.jac)
+        first_part = parts.pop(0).strip()
+        self.emit_ln(
+            node, f"{first_part} {parts.pop(0).strip()} {parts.pop(0).strip()}"
+        )
+        for j in range(0, len(parts) - 1, 2):
+            op = parts[j]
+            var = parts[j + 1].strip() if j + 1 < len(parts) else ""
+            if var:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+                self.emit_ln(node, "")
+            else:
+                self.indent_level += 1
+                self.emit(node, op)
+                self.indent_level -= 1
+
+    def handle_long_expression(self, node: ast.AstNode, kid: ast.AstNode) -> None:
+        """Handle long expressions with multiple operators."""
+        parts = re.split(r"(\+|\-|\*|\/)", kid.gen.jac)
+        self.emit_ln(node, f"{parts.pop(0).strip()}")
+        for j in range(0, len(parts) - 1, 2):
+            op = parts[j]
+            var = parts[j + 1].strip() if j + 1 < len(parts) else ""
+            if j < len(parts) - 2:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+                self.emit_ln(node, "")
+            else:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+
     def exit_assignment(self, node: ast.Assignment) -> None:
         """Sub objects.
 
-        target: SubNodeList[AtomType],
-        value: Optional[ExprType | YieldStmt],
-        type_tag: Optional[SubTag[ExprType]],
+        target: SubNodeList[Expr],
+        value: Optional[Expr | YieldExpr],
+        type_tag: Optional[SubTag[Expr]],
         mutable: bool = True,
-        aug_op: Optional[Token] = None
+        aug_op: Optional[Token] = None,
+        semstr: Optional[String] = None,
+        is_enum_stmt: bool = False,
         """
-        for i in node.kid:
-            if isinstance(i, ast.CommentToken):
-                if i.is_inline:
-                    self.emit(node, i.gen.jac)
+        prev_token = None
+        for kid in node.kid:
+            if isinstance(kid, ast.CommentToken):
+                if kid.is_inline:
+                    self.emit(node, kid.gen.jac)
                 else:
-                    if i.gen.jac not in [
+                    if kid.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)
+                        self.emit_ln(node, kid.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 == ":"
+                        self.emit(node, kid.gen.jac)
+            elif isinstance(kid, ast.Token) and (
+                kid.name == Tok.KW_LET or kid.gen.jac == ":"
             ):
-                self.emit(node, f"{i.gen.jac} ")
-            elif isinstance(i, ast.Token) and "=" in i.gen.jac:
-                self.emit(node, f" {i.gen.jac} ")
+                self.emit(node, f"{kid.gen.jac} ")
+            elif isinstance(kid, ast.Token) and "=" in kid.gen.jac:
+                self.emit(node, f" {kid.gen.jac} ")
+            elif (
+                "=" in kid.gen.jac
+                and self.is_line_break_needed(
+                    kid.gen.jac, max_line_length=self.MAX_LINE_LENGTH * 2
+                )
+                and "\n" not in kid.gen.jac
+            ):
+                self.handle_long_assignment(node, kid)
+            elif (
+                prev_token
+                and "=" in prev_token.gen.jac
+                and self.is_line_break_needed(
+                    kid.gen.jac, max_line_length=self.MAX_LINE_LENGTH * 2
+                )
+                and "\n" not in kid.gen.jac
+            ):
+                self.handle_long_expression(node, kid)
             else:
-                self.emit(node, i.gen.jac)
+                self.emit(node, kid.gen.jac)
+            prev_token = kid
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -2386,7 +2428,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, f"<>{node.value}" if node.is_kwesc else node.value)
 
-    def enter_float(self, node: ast.Float) -> None:
+    def exit_float(self, node: ast.Float) -> None:
         """Sub objects.
 
         name: str,
@@ -2399,7 +2441,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, node.value)
 
-    def enter_int(self, node: ast.Int) -> None:
+    def exit_int(self, node: ast.Int) -> None:
         """Sub objects.
 
         name: str,
@@ -2412,7 +2454,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, node.value)
 
-    def enter_string(self, node: ast.String) -> None:
+    def exit_string(self, node: ast.String) -> None:
         """Sub objects.
 
         name: str,
@@ -2424,7 +2466,11 @@ class JacFormatPass(Pass):
         pos_end: int,
         """
         # if string is in docstring format and spans multiple lines turn into the multiple single quoted strings
-        if "\n" in node.value and node.parent and isinstance(node.parent, ast.Expr):
+        if "\n" in node.value and (
+            node.parent
+            and isinstance(node.parent, ast.Expr)
+            and not isinstance(node.parent, ast.MultiString)
+        ):
             string_type = node.value[0:3]
             pure_string = node.value[3:-3]
             lines = pure_string.split("\n")
@@ -2442,14 +2488,14 @@ class JacFormatPass(Pass):
             string_type = node.value[0:3]
             pure_string = node.value[3:-3]
             lines = pure_string.split("\n")
-            self.emit(node, string_type)
-            for line in lines[:-1]:
-                self.emit_ln(node, line)
-            self.emit_ln(node, f"{lines[-1]}{string_type}")
+            self.emit_ln(node, f"{string_type}{lines[0].lstrip()}")
+            for line in lines[1:-1]:
+                self.emit_ln(node, line.lstrip())
+            self.emit(node, f"{lines[-1].lstrip()}{string_type}")
         else:
             self.emit(node, node.value)
 
-    def enter_bool(self, node: ast.Bool) -> None:
+    def exit_bool(self, node: ast.Bool) -> None:
         """Sub objects.
 
         name: str,

jaclang/compiler/passes/tool/tests/fixtures/corelib.jac

@@ -32,7 +32,7 @@ obj ExecutionContext {
 "Global Execution Context, should be monkey patched by the user."
 glob exec_ctx = ExecutionContext();
 
-obj ElementAnchor {
+obj Anchor :ArchitypeProtocol: {
     has ob: object,
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
@@ -41,8 +41,12 @@ obj ElementAnchor {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory;
+        mem: Memory = exec_ctx.memory,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc];
 
+    static can on_entry(cls: type, triggers: list[type]);
+    static can on_exit(cls: type, triggers: list[type]);
     can make_public_ro;
     can make_public_rw;
     can make_private;
@@ -55,15 +59,7 @@ obj ElementAnchor {
     can revoke_access(caller_id: UUID);
 }
 
-obj ObjectAnchor :ElementAnchor, ArchitypeProtocol: {
-    has ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
-
-    static can on_entry(cls: type, triggers: list[type]);
-    static can on_exit(cls: type, triggers: list[type]);
-}
-
-obj NodeAnchor :ObjectAnchor: {
+obj NodeAnchor :Anchor: {
     has edges: dict[EdgeDir, list[Edge]] = {EdgeDir.IN: [], EdgeDir.OUT: []};
 
     can connect_node(nd: Node, edg: Edge) -> Node;
@@ -71,7 +67,7 @@ obj NodeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj EdgeAnchor :ObjectAnchor: {
+obj EdgeAnchor :Anchor: {
     has source: Node = None,
         target: Node = None,
         dir: EdgeDir = None;
@@ -81,7 +77,7 @@ obj EdgeAnchor :ObjectAnchor: {
     can __call__(walk: Walker);
 }
 
-obj WalkerAnchor :ObjectAnchor: {
+obj WalkerAnchor :Anchor: {
     has path: list[Node] = [],
         next: list[Node] = [],
         ignores: list[Node] = [],
@@ -94,27 +90,27 @@ obj WalkerAnchor :ObjectAnchor: {
 }
 
 obj Root :AbsRootHook: {
-    has _jac_: NodeAnchor | None = None;
+    has __jac__: NodeAnchor | None = None;
 
     can postinit {
-        self._jac_ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = NodeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj GenericEdge :ArchitypeProtocol: {
-    has _jac_: EdgeAnchor | None = None;
+    has __jac__: EdgeAnchor | None = None;
 
     can postinit {
-        self._jac_ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
+        self.__jac__ = EdgeAnchor(self, ds_entry_funcs=[], ds_exit_funcs=[]);
     }
 }
 
 obj Master {
-    has _jac_: ElementAnchor | None = None;
+    has __jac__: Anchor | None = None;
     has root_node: Root = Root(Root);
 
     can postinit {
-        self._jac_ = ElementAnchor(self);
+        self.__jac__ = Anchor(self);
     }
 }
 
@@ -204,31 +200,31 @@ obj JacPlugin {
     PRIVATE
 }
 
-:obj:ElementAnchor:can:make_public_ro {
+:obj:Anchor:can:make_public_ro {
     self.__jinfo.access_mode = AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:make_public_rw {
+:obj:Anchor:can:make_public_rw {
     self.__jinfo.access_mode = AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:make_private {
+:obj:Anchor:can:make_private {
     self.__jinfo.access_mode = AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_public_ro -> bool {
+:obj:Anchor:can:is_public_ro -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_ONLY;
 }
 
-:obj:ElementAnchor:can:is_public_rw -> bool {
+:obj:Anchor:can:is_public_rw -> bool {
     return self.__jinfo.access_mode == AccessMode.READ_WRITE;
 }
 
-:obj:ElementAnchor:can:is_private -> bool {
+:obj:Anchor:can:is_private -> bool {
     return self.__jinfo.access_mode == AccessMode.PRIVATE;
 }
 
-:obj:ElementAnchor:can:is_readable
+:obj:Anchor:can:is_readable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_read
@@ -236,14 +232,14 @@ obj JacPlugin {
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:is_writable
+:obj:Anchor:can:is_writable
 (caller_id: UUID) -> bool {
     return (caller_id == self.owner_id
         or |> self.is_public_write
         or caller_id in self.rw_access);
 }
 
-:obj:ElementAnchor:can:give_access
+:obj:Anchor:can:give_access
 (caller_id: UUID, read_write: bool=False) {
     if read_write {
         caller_id |> self.rw_access.add;
@@ -252,13 +248,13 @@ obj JacPlugin {
     }
 }
 
-:obj:ElementAnchor:can:revoke_access
+:obj:Anchor:can:revoke_access
 (caller_id: UUID) {
     caller_id |> self.ro_access.discard;
     caller_id |> self.rw_access.discard;
 }
 
-:obj:ObjectAnchor:can:on_entry
+:obj:Anchor:can:on_entry
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_entry_funcs.append(
@@ -272,7 +268,7 @@ obj JacPlugin {
     return decorator;
 }
 
-:obj:ObjectAnchor:can:on_exit
+:obj:Anchor:can:on_exit
 (cls: type, triggers: list) {
     can decorator(func: callable) -> callable {
         cls.ds_exit_funcs.append(
@@ -361,7 +357,7 @@ obj JacPlugin {
 
 :obj:NodeAnchor:can:__call__
 (walk: object) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
     walk(self);
@@ -369,10 +365,10 @@ obj JacPlugin {
 
 :obj:EdgeAnchor:can:__call__
 (walk: EdgeInterface) {
-    if not isinstance(walk._jac_, WalkerAnchor) {
+    if not isinstance(walk.__jac__, WalkerAnchor) {
         raise TypeError("Argument must be a Walker instance");
     }
-    walk(self._jac_.target);
+    walk(self.__jac__.target);
 }
 
 :obj:WalkerAnchor:can:__call__
@@ -423,25 +419,25 @@ obj JacPlugin {
 (arch: AT, arch_type: str, on_entry: list[DSFunc], on_exit: list[DSFunc]) -> bool {
     match arch_type {
         case 'obj':
-            arch._jac_ = ObjectAnchor(
+            arch.__jac__ = Anchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'node':
-            arch._jac_ = NodeAnchor(
+            arch.__jac__ = NodeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'edge':
-            arch._jac_ = EdgeAnchor(
+            arch.__jac__ = EdgeAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
             );
         case 'walker':
-            arch._jac_ = WalkerAnchor(
+            arch.__jac__ = WalkerAnchor(
                 ob=arch,
                 ds_entry_funcs=on_entry,
                 ds_exit_funcs=on_exit
@@ -464,19 +460,19 @@ obj JacPlugin {
         edg_type = edge_spec[1];
     }
     edg = edg_type(*(edge_spec[2])) if edge_spec[2] else edg_type();
-    edg._jac_.apply_dir(edge_spec[0]);
+    edg.__jac__.apply_dir(edge_spec[0]);
     return edg;
 }
 
 :obj:JacPlugin:can:connect
 (left: T, right: T, edge_spec: tuple[int, Optional[type], Optional[tuple]]) -> Architype {
     edg = JacPlugin.build_edge(edge_spec);
-    left.connect_node(right._jac_, edg._jac_);
+    left.connect_node(right.__jac__, edg.__jac__);
 }
 
 :obj:JacPlugin:can:visit_node
 (walker_obj: Any, expr: Any) -> bool {
-    return walker_obj._jac_.visit_node(expr);
+    return walker_obj.__jac__.visit_node(expr);
 }
 
 glob expected_area = 78.53981633974483;