jaclang 0.7.20__tar.gz → 0.7.23__tar.gz

{jaclang-0.7.20 → jaclang-0.7.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.20
+Version: 0.7.23
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT

jaclang-0.7.23/jaclang/__init__.py

@@ -0,0 +1,12 @@
+"""The Jac Programming Language."""
+
+from jaclang.plugin.default import JacFeatureImpl
+from jaclang.plugin.feature import JacFeature, plugin_manager
+
+jac_import = JacFeature.jac_import
+
+
+plugin_manager.register(JacFeatureImpl)
+plugin_manager.load_setuptools_entrypoints("jac")
+
+__all__ = ["jac_import"]

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/cli/cli.py

@@ -28,6 +28,7 @@ from jaclang.utils.lang_tools import AstTool
 
 
 Cmd.create_cmd()
+Jac.setup()
 
 
 @cmd_registry.register
@@ -283,7 +284,9 @@ def enter(
 
             jctx.set_entry_node(node)
 
-            if isinstance(architype, WalkerArchitype) and jctx.validate_access():
+            if isinstance(architype, WalkerArchitype) and Jac.check_read_access(
+                jctx.entry_node
+            ):
                 Jac.spawn_call(jctx.entry_node.architype, architype)
 
     jctx.close()

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/compiler/absyntree.py

@@ -2873,13 +2873,24 @@ class FString(AtomExpr):
         if deep:
             res = self.parts.normalize(deep) if self.parts else res
         new_kid: list[AstNode] = []
+        is_single_quote = (
+            isinstance(self.kid[0], Token) and self.kid[0].name == Tok.FSTR_SQ_START
+        )
         if self.parts:
+            if is_single_quote:
+                new_kid.append(self.gen_token(Tok.FSTR_SQ_START))
+            else:
+                new_kid.append(self.gen_token(Tok.FSTR_START))
             for i in self.parts.items:
                 if isinstance(i, String):
                     i.value = (
                         "{{" if i.value == "{" else "}}" if i.value == "}" else i.value
                     )
             new_kid.append(self.parts)
+            if is_single_quote:
+                new_kid.append(self.gen_token(Tok.FSTR_SQ_END))
+            else:
+                new_kid.append(self.gen_token(Tok.FSTR_END))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -4257,7 +4268,6 @@ class String(Literal):
         """Return literal value in its python type."""
         if isinstance(self.value, bytes):
             return self.value
-        prefix_len = 3 if self.value.startswith(("'''", '"""')) else 1
         if any(
             self.value.startswith(prefix)
             and self.value[len(prefix) :].startswith(("'", '"'))
@@ -4266,8 +4276,23 @@ class String(Literal):
             return eval(self.value)
 
         elif self.value.startswith(("'", '"')):
-            ret_str = self.value[prefix_len:-prefix_len]
-            return ret_str.encode().decode("unicode_escape", errors="backslashreplace")
+            repr_str = self.value.encode().decode("unicode_escape")
+            if (
+                self.value.startswith('"""')
+                and self.value.endswith('"""')
+                and not self.find_parent_of_type(FString)
+            ):
+                return repr_str[3:-3]
+            if (not self.find_parent_of_type(FString)) or (
+                not (
+                    self.parent
+                    and isinstance(self.parent, SubNodeList)
+                    and self.parent.parent
+                    and isinstance(self.parent.parent, FString)
+                )
+            ):
+                return repr_str[1:-1]
+            return repr_str
         else:
             return self.value
 

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/compiler/jac.lark

@@ -25,7 +25,7 @@ from_path: (DOT | ELLIPSIS)* import_path
          | (DOT | ELLIPSIS)+
 
 import_path: named_ref (DOT named_ref)* (KW_AS NAME)?
-import_items: (import_item COMMA)* import_item
+import_items: (import_item COMMA)* import_item COMMA?
 import_item: named_ref (KW_AS NAME)?
 sub_name: COLON NAME
 include_stmt: KW_INCLUDE sub_name? import_path SEMI
@@ -63,7 +63,7 @@ enum: decorators? enum_decl
 
 enum_decl: KW_ENUM access_tag? STRING? NAME inherited_archs? (enum_block | SEMI)
 enum_def: arch_to_enum_chain enum_block
-enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt)? RBRACE
+enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt COMMA?)? RBRACE
 
 enum_stmt: NAME (COLON STRING)? EQ expression
          | NAME (COLON STRING)?
@@ -83,7 +83,7 @@ abstract_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING? named_ref (
 genai_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING? named_ref (func_decl) KW_BY atomic_call SEMI
 event_clause: KW_WITH expression? (KW_EXIT | KW_ENTRY) (STRING? RETURN_HINT expression)?
 func_decl: (LPAREN func_decl_params? RPAREN)? (RETURN_HINT (STRING COLON)? expression)?
-func_decl_params: (param_var COMMA)* param_var
+func_decl_params: (param_var COMMA)* param_var COMMA?
 param_var: (STAR_POW | STAR_MUL)? NAME (COLON STRING)? type_tag (EQ expression)?
 
 // Global variables
@@ -364,9 +364,9 @@ index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
 // Function calls
 atomic_call: atomic_chain LPAREN param_list? (KW_BY atomic_call)? RPAREN
 
-param_list: expr_list COMMA kw_expr_list
-          | kw_expr_list
-          | expr_list
+param_list: expr_list COMMA kw_expr_list COMMA?
+          | kw_expr_list COMMA?
+          | expr_list COMMA?
 
 // Atom
 atom: named_ref
@@ -412,20 +412,20 @@ set_compr: LBRACE expression inner_compr+ RBRACE
 dict_compr: LBRACE kv_pair inner_compr+ RBRACE
 inner_compr: KW_ASYNC? KW_FOR atomic_chain KW_IN pipe_call (KW_IF walrus_assign)*
 
-dict_val: LBRACE ((kv_pair COMMA)* kv_pair)? RBRACE
-list_val: LSQUARE expr_list? RSQUARE
+dict_val: LBRACE ((kv_pair COMMA)* kv_pair COMMA?)? RBRACE
+list_val: LSQUARE (expr_list COMMA?)? RSQUARE
 tuple_val: LPAREN tuple_list? RPAREN
-set_val: LBRACE expr_list RBRACE
+set_val: LBRACE expr_list COMMA? RBRACE
 
 kv_pair: expression COLON expression | STAR_POW expression
 expr_list: (expr_list COMMA)? expression
 
 // Tuples and Jac Tuples
-tuple_list: expression COMMA expr_list COMMA kw_expr_list
-          | expression COMMA kw_expr_list
-          | expression COMMA expr_list
+tuple_list: expression COMMA expr_list COMMA kw_expr_list COMMA?
+          | expression COMMA kw_expr_list COMMA?
+          | expression COMMA expr_list COMMA?
           | expression COMMA
-          | kw_expr_list
+          | kw_expr_list COMMA?
 
 kw_expr_list: (kw_expr_list COMMA)? kw_expr
 kw_expr: named_ref EQ expression | STAR_POW expression
@@ -662,4 +662,4 @@ FSTR_BESC.1: /{{|}}/
 COMMENT: /#\*(.|\n|\r)*?\*#|#.*/
 WS.-2: /[ \t\f\r\n]/+
 %ignore COMMENT
-%ignore WS
+%ignore WS

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/compiler/parser.py

@@ -429,7 +429,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.ModuleItem]:
             """Grammar rule.
 
-            import_items: (import_item COMMA)* import_item
+            import_items: (import_item COMMA)* import_item COMMA?
             """
             ret = ast.SubNodeList[ast.ModuleItem](
                 items=[i for i in kid if isinstance(i, ast.ModuleItem)],
@@ -693,7 +693,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.EnumBlockStmt]:
             """Grammar rule.
 
-            enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt)? RBRACE
+            enum_block: LBRACE ((enum_stmt COMMA)* enum_stmt COMMA?)? RBRACE
             """
             ret = ast.SubNodeList[ast.EnumBlockStmt](items=[], delim=Tok.COMMA, kid=kid)
             ret.items = [i for i in kid if isinstance(i, ast.EnumBlockStmt)]
@@ -1022,7 +1022,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.ParamVar]:
             """Grammar rule.
 
-            func_decl_params: (param_var COMMA)* param_var
+            func_decl_params: (param_var COMMA)* param_var COMMA?
             """
             ret = ast.SubNodeList[ast.ParamVar](
                 items=[i for i in kid if isinstance(i, ast.ParamVar)],
@@ -1267,29 +1267,30 @@ class JacParser(Pass):
         def statement(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt:
             """Grammar rule.
 
-            statement: py_code_block
-                    | walker_stmt
-                    | return_stmt SEMI
-                    | report_stmt SEMI
-                    | delete_stmt SEMI
-                    | ctrl_stmt SEMI
-                    | assert_stmt SEMI
-                    | raise_stmt SEMI
-                    | with_stmt
+            statement: import_stmt
+                    | ability
+                    | architype
+                    | if_stmt
                     | while_stmt
                     | for_stmt
                     | try_stmt
-                    | if_stmt
-                    | expression SEMI
-                    | (yield_expr | KW_YIELD) SEMI
-                    | static_assignment
-                    | assignment SEMI
+                    | match_stmt
+                    | with_stmt
                     | global_ref SEMI
                     | nonlocal_ref SEMI
                     | typed_ctx_block
-                    | ability
-                    | architype
-                    | import_stmt
+                    | return_stmt SEMI
+                    | (yield_expr | KW_YIELD) SEMI
+                    | raise_stmt SEMI
+                    | assert_stmt SEMI
+                    | check_stmt SEMI
+                    | assignment SEMI
+                    | delete_stmt SEMI
+                    | report_stmt SEMI
+                    | expression SEMI
+                    | ctrl_stmt SEMI
+                    | py_code_block
+                    | walker_stmt
                     | SEMI
             """
             if isinstance(kid[0], ast.CodeBlockStmt) and len(kid) < 2:
@@ -2180,30 +2181,21 @@ class JacParser(Pass):
         def arithmetic(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            arithmetic: term MINUS arithmetic
-                      | term PLUS arithmetic
-                      | term
+            arithmetic: (arithmetic (MINUS | PLUS))? term
             """
             return self.binary_expr_unwind(kid)
 
         def term(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            term: factor MOD term
-                 | factor DIV term
-                 | factor FLOOR_DIV term
-                 | factor STAR_MUL term
-                 | factor
+            term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? power
             """
             return self.binary_expr_unwind(kid)
 
         def factor(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            factor: power
-                  | BW_NOT factor
-                  | MINUS factor
-                  | PLUS factor
+            factor: (BW_NOT | MINUS | PLUS) factor | connect
             """
             if len(kid) == 2:
                 if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
@@ -2221,8 +2213,7 @@ class JacParser(Pass):
         def power(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            power: connect STAR_POW power
-                  | connect
+            power: (power STAR_POW)? factor
             """
             return self.binary_expr_unwind(kid)
 
@@ -2513,8 +2504,7 @@ class JacParser(Pass):
         def yield_expr(self, kid: list[ast.AstNode]) -> ast.YieldExpr:
             """Grammar rule.
 
-            yield_expr:
-                | KW_YIELD KW_FROM? expression
+            yield_expr: KW_YIELD KW_FROM? expression
             """
             if isinstance(kid[-1], ast.Expr):
                 return self.nu(
@@ -2565,7 +2555,7 @@ class JacParser(Pass):
         def multistring(self, kid: list[ast.AstNode]) -> ast.AtomExpr:
             """Grammar rule.
 
-            multistring: (fstring | STRING)+
+            multistring: (fstring | STRING | DOC_STRING)+
             """
             valid_strs = [i for i in kid if isinstance(i, (ast.String, ast.FString))]
             if len(valid_strs) == len(kid):
@@ -2582,6 +2572,7 @@ class JacParser(Pass):
             """Grammar rule.
 
             fstring: FSTR_START fstr_parts FSTR_END
+                | FSTR_SQ_START fstr_sq_parts FSTR_SQ_END
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2605,7 +2596,7 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.String | ast.ExprStmt]:
             """Grammar rule.
 
-            fstr_parts: (FSTR_PIECE | FSTR_BESC | LBRACE expression RBRACE | fstring)*
+            fstr_parts: (FSTR_PIECE | FSTR_BESC | LBRACE expression RBRACE )*
             """
             valid_parts: list[ast.String | ast.ExprStmt] = [
                 (
@@ -2651,7 +2642,7 @@ class JacParser(Pass):
         def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal:
             """Grammar rule.
 
-            list_val: LSQUARE expr_list? RSQUARE
+            list_val: LSQUARE (expr_list COMMA?)? RSQUARE
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2695,7 +2686,7 @@ class JacParser(Pass):
         def set_val(self, kid: list[ast.AstNode]) -> ast.SetVal:
             """Grammar rule.
 
-            set_val: LBRACE expr_list RBRACE
+            set_val: LBRACE expr_list COMMA? RBRACE
             """
             if len(kid) == 2:
                 return self.nu(
@@ -2822,25 +2813,37 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
             """Grammar rule.
 
-            tuple_list: expression COMMA expr_list COMMA kw_expr_list
-                    | expression COMMA kw_expr_list
-                    | expression COMMA expr_list
-                    | expression COMMA
-                    | kw_expr_list
+            tuple_list: expression COMMA expr_list    COMMA kw_expr_list COMMA?
+                      | expression COMMA kw_expr_list COMMA?
+                      | expression COMMA expr_list    COMMA?
+                      | expression COMMA
+                      | kw_expr_list COMMA?
             """
             chomp = [*kid]
             first_expr = None
             if isinstance(chomp[0], ast.SubNodeList):
+                # The chomp will be like this:
+                #     kw_expr_list, [COMMA]
+                if len(chomp) > 1:
+                    # Add the comma to the subnode list if it exists, otherwise the last comma will not be a part of
+                    # the ast, we need it for formatting.
+                    chomp[0].kid.append(chomp[1])
                 return self.nu(chomp[0])
             else:
-                first_expr = chomp[0]
-                chomp = chomp[2:]
+                # The chomp will be like this:
+                #     expression, COMMA, [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
+                # Pop the first expression from chomp.
+                first_expr = chomp[0]  # Get the first expression.
+                chomp = chomp[2:]  # Get rid of expr and comma.
+
+            # The chomp will be like this:
+            #     [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
             expr_list = []
             if len(chomp):
-                expr_list = chomp[0].kid
-                chomp = chomp[1:]
+                expr_list = chomp[0].kid  # Get the kids subnode list.
+                chomp = chomp[2:]  # Get rid of the subnode list and a comma if exists.
                 if len(chomp):
-                    chomp = chomp[1:]
+                    # The chomp will be like this: [kw_expr_list, [COMMA]]
                     expr_list = [*expr_list, *chomp[0].kid]
             expr_list = [first_expr, *expr_list]
             valid_kid = [i for i in expr_list if isinstance(i, (ast.Expr, ast.KWPair))]
@@ -2855,7 +2858,7 @@ class JacParser(Pass):
         def dict_val(self, kid: list[ast.AstNode]) -> ast.DictVal:
             """Grammar rule.
 
-            dict_val: LBRACE ((kv_pair COMMA)* kv_pair)? RBRACE
+            dict_val: LBRACE ((kv_pair COMMA)* kv_pair COMMA?)? RBRACE
             """
             ret = ast.DictVal(
                 kv_pairs=[],
@@ -2912,7 +2915,7 @@ class JacParser(Pass):
         def gen_compr(self, kid: list[ast.AstNode]) -> ast.GenCompr:
             """Grammar rule.
 
-            gen_compr: LSQUARE expression inner_compr+ RSQUARE
+            gen_compr: LPAREN expression inner_compr+ RPAREN
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr):
@@ -2929,7 +2932,7 @@ class JacParser(Pass):
         def set_compr(self, kid: list[ast.AstNode]) -> ast.SetCompr:
             """Grammar rule.
 
-            set_compr: LSQUARE expression inner_compr+ RSQUARE
+            set_compr: LBRACE expression inner_compr+ RBRACE
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.InnerCompr):
@@ -2993,12 +2996,21 @@ class JacParser(Pass):
         ) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
             """Grammar rule.
 
-            param_list: expr_list COMMA kw_expr_list
-                    | kw_expr_list
-                    | expr_list
+            param_list: expr_list    COMMA kw_expr_list COMMA?
+                      | kw_expr_list COMMA?
+                      | expr_list    COMMA?
             """
-            if len(kid) == 1:
+            ends_with_comma = (
+                len(kid) > 1
+                and isinstance(kid[-1], ast.Token)
+                and kid[-1].name == "COMMA"
+            )
+            if len(kid) == 1 or (len(kid) == 2 and ends_with_comma):
                 if isinstance(kid[0], ast.SubNodeList):
+                    if (
+                        ends_with_comma
+                    ):  # Append the trailing comma to the subnode list.
+                        kid[0].kid.append(kid[1])
                     return self.nu(kid[0])
                 else:
                     raise self.ice()
@@ -3146,7 +3158,7 @@ class JacParser(Pass):
         def type_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
-            type_ref: TYPE_OP name_ref
+            type_ref: TYPE_OP (named_ref | builtin_type)
             """
             if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
                 return self.nu(

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/compiler/passes/main/pyast_load_pass.py

@@ -1148,14 +1148,16 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             else:
                 token_type = f"{value_type.__name__.upper()}"
 
+            if value_type == str:
+                raw_repr = repr(node.value)
+                quote = "'" if raw_repr.startswith("'") else '"'
+                value = f"{quote}{raw_repr[1:-1]}{quote}"
+            else:
+                value = str(node.value)
             return type_mapping[value_type](
                 file_path=self.mod_path,
                 name=token_type,
-                value=(
-                    f'"{repr(node.value)[1:-1]}"'
-                    if value_type == str
-                    else str(node.value)
-                ),
+                value=value,
                 line=node.lineno,
                 end_line=node.end_lineno if node.end_lineno else node.lineno,
                 col_start=node.col_offset,
@@ -2625,7 +2627,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
 
     def convert_to_doc(self, string: ast.String) -> None:
         """Convert a string to a docstring."""
-        string.value = f'""{string.value}""'
+        string.value = f'"""{string.value[1:-1]}"""'
 
     def aug_op_map(self, tok_dict: dict, op: ast.Token) -> str:
         """aug_mapper."""

jaclang-0.7.23/jaclang/compiler/passes/main/tests/fixtures/fstrings.jac

@@ -0,0 +1,47 @@
+"""Small test for fstrings."""
+
+glob apple = 2;
+glob a=f"hello {40 + 2}   wor{apple}ld  ";
+
+with entry {
+    a = 9;
+    s_2 = "'''hello'''";
+    s_3 = "'''hello  '''";
+    s_4 = "''' hello'''";
+    s_5 = '""" hello"""';
+    s_6 = '"""hello"""';
+    s_7 = '"""hello"" "';
+    s_8 = '"""hello""" ';
+    print(
+        len(s_2),
+        len(s_3),
+        len(s_4),
+        len(s_5),
+        len(s_6),
+        len(s_7),
+        len(s_8)
+    ) ;
+    b1 = f"{"'''hello''' "}";
+    b_2 = f"{'"""hello""" '}";
+    f_1 = f"{'hello '}{a}{'"""hello"""'}";
+    f_2 = f"{'hello '}{a}{"'''hello'''"}";
+    print(len(b1),len(b_2), b_2,len(f_1), len(f_2)) ;
+    f_3 = f"{'"""again"""'}";
+    f_4 = f"{'"""again""" '}";
+    f_5 = f"{"'''again'''"}";
+    f_6 = f"{"'''again''' "}";
+    f_7 = f"{'"""again"""'}";
+    f_s1 = f"{'hello '}{a}{'"""hello"""'}";
+    f_s2 = f"{'hello '}{a}{"'''hello'''"}{'kklkl'}";
+    print(
+        len(f_3),
+        len(f_4),
+        len(f_5),
+        len(f_6),
+        len(f_7),
+        len(f_s1), len(f_s2)
+    ) ;
+    """sdfsdf\nsdfsdfsdfsd dffgdfgd.""" ;
+}
+can func() {;
+}

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/compiler/passes/main/type_check_pass.py

@@ -50,12 +50,6 @@ class JacTypeCheckPass(Pass):
         options = myab.myb.Options()
         options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
-        options.mypy_path = [
-            # str( # TODO: Remove me, this was the wrong way to point to stubs
-            #     pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
-            #     / "stubs"
-            # )
-        ]
         if top_module_path != "":
             options.mypy_path.append(top_module_path)
 
@@ -116,6 +110,14 @@ class JacTypeCheckPass(Pass):
             old_graph=mypy_graph,
             new_modules=new_modules,  # To parse the dependancies of modules
         )
+        mypy_graph = {
+            k: v
+            for k, v in mypy_graph.items()
+            if (
+                k.startswith("jaclang.plugin")
+                or not (k.startswith("jaclang.") or k.startswith("mypy."))
+            )
+        }
         for i in mypy_graph:
             self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
             for j in mypy_graph[i].dependencies:

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -404,7 +404,9 @@ class JacFormatPass(Pass):
                     indented = True
                 for count, j in enumerate(i.kid):
                     if j.gen.jac == ",":
-                        if i.kid[count + 1].gen.jac.startswith("#"):
+                        if len(i.kid) > count + 1 and i.kid[
+                            count + 1
+                        ].gen.jac.startswith("#"):
                             self.indent_level -= 1
                             self.emit(node, f"{j.gen.jac} ")
                             self.indent_level += 1

{jaclang-0.7.20 → jaclang-0.7.23}/jaclang/plugin/builtin.py

@@ -19,9 +19,9 @@ def dotgen(
     dot_file: Optional[str] = None,
 ) -> str:
     """Print the dot graph."""
-    from jaclang.plugin.feature import pm
+    from jaclang.plugin.feature import JacFeature as Jac
 
-    root = pm.hook.get_root()
+    root = Jac.get_root()
     node = node if node is not None else root
     depth = depth if depth is not None else -1
     traverse = traverse if traverse is not None else False
@@ -29,7 +29,7 @@ def dotgen(
     edge_limit = edge_limit if edge_limit is not None else 512
     node_limit = node_limit if node_limit is not None else 512
 
-    return pm.hook.dotgen(
+    return Jac.dotgen(
         edge_type=edge_type,
         node=node,
         depth=depth,