jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -19,8 +19,6 @@ T = TypeVar("T", bound=ast3.AST)
 class PyastGenPass(Pass):
     """Jac blue transpilation to python pass."""
 
-    cout = 1
-
     @staticmethod
     def node_compilable_test(node: ast3.AST) -> None:
         """Convert any AST node to a compilable module node."""
@@ -214,25 +212,18 @@ class PyastGenPass(Pass):
                 i.end_lineno = (
                     jac_node.loc.last_line
                     if jac_node.loc.last_line
+                    and (jac_node.loc.last_line > jac_node.loc.first_line)
                     else jac_node.loc.first_line
                 )
                 i.end_col_offset = (
                     jac_node.loc.col_end
                     if jac_node.loc.col_end
+                    and (jac_node.loc.col_end > jac_node.loc.col_start)
                     else jac_node.loc.col_start
                 )
                 i.jac_link: list[ast3.AST] = [jac_node]  # type: ignore
         return py_node
 
-    def link_jac_py_nodes(
-        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
-    ) -> None:
-        """Link jac name ast to py ast nodes."""
-        jac_node.gen.py_ast = py_nodes
-        for i in py_nodes:
-            if isinstance(i.jac_link, list):  # type: ignore
-                i.jac_link.append(jac_node)  # type: ignore
-
     def pyinline_sync(
         self,
         py_nodes: list[ast3.AST],
@@ -329,7 +320,10 @@ class PyastGenPass(Pass):
         is_imported: bool,
         """
         clean_body = [i for i in node.body if not isinstance(i, ast.AstImplOnlyNode)]
-        pre_body = [*node.impl_mod.body, *clean_body] if node.impl_mod else clean_body
+        pre_body: list[ast.AstNode] = []
+        for pbody in node.impl_mod:
+            pre_body = [*pre_body, *pbody.body]
+        pre_body = [*pre_body, *clean_body]
         pre_body = [*pre_body, *node.test_mod.body] if node.test_mod else pre_body
         body = (
             [
@@ -648,8 +642,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if node.alias:
-            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_module_item(self, node: ast.ModuleItem) -> None:
         """Sub objects.
@@ -776,9 +768,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
-        if isinstance(node.body, ast.ArchDef):
-            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def collect_events(
         self, node: ast.Architype
@@ -831,12 +820,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
-                self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
-                )
 
     def exit_enum(self, node: ast.Enum) -> None:
         """Sub objects.
@@ -877,8 +860,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if isinstance(node.body, ast.EnumDef):
-            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def exit_enum_def(self, node: ast.EnumDef) -> None:
         """Sub objects.
@@ -888,12 +869,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
-                self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
-                )
 
     def exit_ability(self, node: ast.Ability) -> None:
         """Sub objects.
@@ -995,9 +970,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.name_ref, py_nodes=node.gen.py_ast)
-        if isinstance(node.body, ast.AbilityDef):
-            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
 
     def gen_llm_body(self, node: ast.Ability) -> list[ast3.AST]:
         """Generate llm body."""
@@ -1291,15 +1263,6 @@ class PyastGenPass(Pass):
         doc: Optional[String],
         decorators: Optional[SubNodeList[ExprType]],
         """
-        for i in node.target.archs:
-            if i.sym_link:
-                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
-                self.link_jac_py_nodes(
-                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
-                )
-        if isinstance(node.parent, ast.Ability) and node.parent.signature:
-            # TODO: Here we need to do a link for each subnode to the original parent signature
-            pass
 
     def exit_func_signature(self, node: ast.FuncSignature) -> None:
         """Sub objects.
@@ -1464,7 +1427,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
 
     def exit_arch_has(self, node: ast.ArchHas) -> None:
         """Sub objects.
@@ -1720,8 +1682,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if node.name:
-            self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
 
     def exit_finally_stmt(self, node: ast.FinallyStmt) -> None:
         """Sub objects.
@@ -1829,9 +1789,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        self.link_jac_py_nodes(jac_node=node.expr, py_nodes=node.gen.py_ast)
-        if node.alias:
-            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
 
     def exit_raise_stmt(self, node: ast.RaiseStmt) -> None:
         """Sub objects.
@@ -2089,7 +2046,6 @@ class PyastGenPass(Pass):
                     jac_node=x,
                 )
             )
-            self.link_jac_py_nodes(jac_node=x, py_nodes=[py_nodes[-1]])
         node.gen.py_ast = [*py_nodes]
 
     def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None:
@@ -2105,7 +2061,6 @@ class PyastGenPass(Pass):
                     jac_node=x,
                 )
             )
-            self.link_jac_py_nodes(jac_node=x, py_nodes=[py_nodes[-1]])
         node.gen.py_ast = [*py_nodes]
 
     def exit_assignment(self, node: ast.Assignment) -> None:
@@ -2647,8 +2602,6 @@ class PyastGenPass(Pass):
                 )
             )
         ]
-        if node.key:
-            self.link_jac_py_nodes(jac_node=node.key, py_nodes=node.gen.py_ast)
 
     def exit_inner_compr(self, node: ast.InnerCompr) -> None:
         """Sub objects.
@@ -2758,9 +2711,6 @@ class PyastGenPass(Pass):
                         )
                     )
                 ]
-                self.link_jac_py_nodes(
-                    jac_node=node.right.sym_name_node, py_nodes=node.gen.py_ast
-                )
             else:
                 self.error("Invalid attribute access")
         elif isinstance(node.right, ast.FilterCompr):
@@ -3025,7 +2975,6 @@ class PyastGenPass(Pass):
                     for kw_pair in node.params.items
                     if isinstance(kw_pair, ast.KWPair)
                 ]
-                self.cout += 1
             else:
                 inputs = []
 

jaclang/compiler/passes/main/pyjac_ast_link_pass.py

@@ -0,0 +1,218 @@
+"""Jac to python ast link pass."""
+
+import ast as ast3
+
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.passes import Pass
+
+
+class PyJacAstLinkPass(Pass):
+    """Link jac ast to python ast nodes."""
+
+    def link_jac_py_nodes(
+        self, jac_node: ast.AstNode, py_nodes: list[ast3.AST]
+    ) -> None:
+        """Link jac name ast to py ast nodes."""
+        jac_node.gen.py_ast = py_nodes
+        for i in py_nodes:
+            if isinstance(i.jac_link, list):  # type: ignore
+                i.jac_link.append(jac_node)  # type: ignore
+
+    def exit_module_path(self, node: ast.ModulePath) -> None:
+        """Sub objects.
+
+        path: Sequence[Token],
+        alias: Optional[Name],
+        path_str: str,
+        """
+        if node.alias:
+            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
+
+    def exit_architype(self, node: ast.Architype) -> None:
+        """Sub objects.
+
+        name: Name,
+        arch_type: Token,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[SubNodeList[AtomType]],
+        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+        if isinstance(node.body, ast.ArchDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def exit_arch_def(self, node: ast.ArchDef) -> None:
+        """Sub objects.
+
+        target: ArchRefChain,
+        body: SubNodeList[ArchBlockStmt],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+
+    def exit_enum(self, node: ast.Enum) -> None:
+        """Sub objects.
+
+        name: Name,
+        access: Optional[SubTag[Token]],
+        base_classes: Optional[Optional[SubNodeList[AtomType]]],
+        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        if isinstance(node.body, ast.EnumDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def exit_enum_def(self, node: ast.EnumDef) -> None:
+        """Sub objects.
+
+        target: ArchRefChain,
+        body: SubNodeList[EnumBlockStmt],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+
+    def exit_ability(self, node: ast.Ability) -> None:
+        """Sub objects.
+
+        name_ref: NameType,
+        is_func: bool,
+        is_async: bool,
+        is_static: bool,
+        is_abstract: bool,
+        access: Optional[SubTag[Token]],
+        signature: Optional[FuncSignature | ExprType | EventSignature],
+        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        self.link_jac_py_nodes(jac_node=node.name_ref, py_nodes=node.gen.py_ast)
+        if isinstance(node.body, ast.AbilityDef):
+            self.link_jac_py_nodes(jac_node=node.body, py_nodes=node.gen.py_ast)
+
+    def exit_ability_def(self, node: ast.AbilityDef) -> None:
+        """Sub objects.
+
+        target: ArchRefChain,
+        signature: FuncSignature | EventSignature,
+        body: SubNodeList[CodeBlockStmt],
+        doc: Optional[String],
+        decorators: Optional[SubNodeList[ExprType]],
+        """
+        for i in node.target.archs:
+            if i.sym_link:
+                self.link_jac_py_nodes(jac_node=i, py_nodes=i.sym_link.decl.gen.py_ast)
+                self.link_jac_py_nodes(
+                    jac_node=i.name_ref, py_nodes=i.sym_link.decl.gen.py_ast
+                )
+
+        if isinstance(node.parent, ast.Ability) and node.parent.signature:
+            if isinstance(node.signature, ast.FuncSignature) and node.signature.params:
+                for src_prm in node.signature.params.items:
+                    if (
+                        isinstance(node.parent.signature, ast.FuncSignature)
+                        and node.parent.signature.params
+                    ):
+                        for trg_prm in node.parent.signature.params.items:
+                            if src_prm.name.sym_name == trg_prm.name.sym_name:
+                                self.link_jac_py_nodes(
+                                    jac_node=src_prm, py_nodes=trg_prm.gen.py_ast
+                                )
+                                self.link_jac_py_nodes(
+                                    jac_node=src_prm.name,
+                                    py_nodes=trg_prm.name.gen.py_ast,
+                                )
+            if (
+                isinstance(node.signature, ast.FuncSignature)
+                and node.signature.return_type
+            ) and (
+                isinstance(node.parent.signature, ast.FuncSignature)
+                and node.parent.signature.return_type
+            ):
+                self.link_jac_py_nodes(
+                    jac_node=node.signature.return_type,
+                    py_nodes=node.parent.signature.return_type.gen.py_ast,
+                )
+
+    def exit_param_var(self, node: ast.ParamVar) -> None:
+        """Sub objects.
+
+        name: Name,
+        unpack: Optional[Token],
+        type_tag: SubTag[ExprType],
+        value: Optional[ExprType],
+        """
+        self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+
+    def exit_except(self, node: ast.Except) -> None:
+        """Sub objects.
+
+        ex_type: ExprType,
+        name: Optional[Name],
+        body: SubNodeList[CodeBlockStmt],
+        """
+        if node.name:
+            self.link_jac_py_nodes(jac_node=node.name, py_nodes=node.gen.py_ast)
+
+    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None:
+        """Sub objects.
+
+        expr: ExprType,
+        alias: Optional[ExprType],
+        """
+        self.link_jac_py_nodes(jac_node=node.expr, py_nodes=node.gen.py_ast)
+        if node.alias:
+            self.link_jac_py_nodes(jac_node=node.alias, py_nodes=node.gen.py_ast)
+
+    def exit_global_stmt(self, node: ast.GlobalStmt) -> None:
+        """Sub objects.
+
+        target: SubNodeList[NameType],
+        """
+        for x, y in enumerate(node.target.items):
+            self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
+
+    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None:
+        """Sub objects.
+
+        target: SubNodeList[NameType],
+        """
+        for x, y in enumerate(node.target.items):
+            self.link_jac_py_nodes(jac_node=y, py_nodes=[node.gen.py_ast[x]])
+
+    def exit_k_w_pair(self, node: ast.KWPair) -> None:
+        """Sub objects.
+
+        key: NameType,
+        value: ExprType,
+        """
+        if node.key:
+            self.link_jac_py_nodes(jac_node=node.key, py_nodes=node.gen.py_ast)
+
+    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None:
+        """Sub objects.
+
+        target: Expr,
+        right: AtomExpr | Expr,
+        is_attr: bool,
+        is_null_ok: bool,
+        is_genai: bool = False,
+        """
+        if node.is_attr and isinstance(node.right, ast.AstSymbolNode):
+            self.link_jac_py_nodes(
+                jac_node=node.right.sym_name_node, py_nodes=node.gen.py_ast
+            )

jaclang/compiler/passes/main/schedules.py

@@ -14,6 +14,7 @@ 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
@@ -28,6 +29,7 @@ py_code_gen = [
     DefUsePass,
     RegistryPass,
     PyastGenPass,
+    PyJacAstLinkPass,
     PyBytecodeGenPass,
 ]
 

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -217,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."""
@@ -263,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

jaclang/compiler/passes/main/tests/fixtures/autoimpl.impl/getme.impl.jac

@@ -0,0 +1,3 @@
+:can:baz {
+    print("baz");
+}

jaclang/compiler/passes/main/tests/fixtures/autoimpl.impl.jac

@@ -0,0 +1,3 @@
+:can:foo {
+  print("foo");
+}

jaclang/compiler/passes/main/tests/fixtures/autoimpl.jac

@@ -0,0 +1,9 @@
+can foo;
+can bar;
+can baz;
+
+with entry {
+    foo();
+    bar();
+    baz();
+}

jaclang/compiler/passes/main/tests/fixtures/autoimpl.something.else.impl.jac

@@ -0,0 +1,3 @@
+:can:bar {
+  print("bar");
+}

jaclang/compiler/passes/main/tests/fixtures/base.jac

@@ -0,0 +1,13 @@
+"""Test for base classes."""
+
+import:jac from impl.imps, test_glob as mine;
+include:jac impl.imps;
+
+obj Test {
+    can init;
+    can say_hi;
+}
+
+with entry {
+    print(f"{mine}");
+}

jaclang/compiler/passes/main/tests/fixtures/base2.jac

@@ -0,0 +1,14 @@
+"""Test for base classes."""
+
+import:jac from impl.imps, test_glob as mine;
+
+obj Test {
+    can init;
+    can say_hi;
+}
+
+with entry {
+    print(f"{mine}");
+}
+
+include:jac impl.imps;

jaclang/compiler/passes/main/tests/fixtures/blip.jac

@@ -0,0 +1,2 @@
+can apple {
+}

jaclang/compiler/passes/main/tests/fixtures/codegentext.jac

@@ -0,0 +1,31 @@
+"""Various samples to see code generated correctly"""
+
+with entry {
+    a = (5 + 10) * 2;
+    {"name":"value" } |> (len |> print |> dump) |> say;
+}
+
+with entry {
+    a = (5 + 10) * 2;
+    {"name":"value" } |> (len |> print :> dump) |> say;
+}
+
+with entry {
+    len <| print <| print <| print <| {"name":"value" };
+}
+
+with entry {
+    (*args, **kwargs) |> self.func;
+    self.sig = func |> inspect.signature;
+    |> self.registry.items;
+}
+
+with entry {
+    with open("file.txt") as f, open("file2.txt") as f2 {}
+}
+
+enum Color  {
+    RED=1,
+    GREEN,
+    BLUE=3
+}

jaclang/compiler/passes/main/tests/fixtures/decls.jac

@@ -0,0 +1,10 @@
+"""Test for jac decls"""
+
+include:jac impl.defs1;
+include:jac impl.defs2;
+
+obj MyObject {
+
+    can foo();
+    can bar();
+}

jaclang/compiler/passes/main/tests/fixtures/defs_and_uses.jac

@@ -0,0 +1,44 @@
+"""Separating Defs and Decls in a single File"""
+
+# Declarations
+can my_print(messag: str) -> str;
+
+# Definitions
+:can:my_print
+(message: str) -> str {
+    output = f"from me: {message}";
+    print("from me: {message}");
+    return output;
+}
+
+# Declaration
+obj MyPrinter {
+    has thing_to_print: str;
+    can my_print(messag: str) -> str; # method declaration
+}
+
+# Definition
+:obj:MyPrinter:can:my_print
+(message: str) -> str {
+    y = ".".join([i for i in range(10)]);
+    output = f"from me: {message} {y}";
+    print(f"from me: {output}");
+    return output;
+}
+
+
+# Decl/Def Combined
+can your_print(messag: str) -> str {
+    output = f"from me: {message}";
+    print("from me: {message}");
+    return output;
+}
+
+# Decl/Def Combined
+obj YourPrinter {
+    can your_print(messag: str) -> str {
+        output = f"from me: {messag}";
+        print("from me: {message}");
+        return output;
+    }
+}

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

@@ -0,0 +1,4 @@
+"""Small test for fstrings."""
+
+
+glob a=f"hello {40 + 2}   wor{apple}ld  ";

jaclang/compiler/passes/main/tests/fixtures/func.jac

@@ -0,0 +1,18 @@
+"""Functions in Jac."""
+
+import:jac from func2, factorial as factorial;
+
+can factorial_recount(n: int) -> int {
+    count: str=0;
+    count+=1;
+    count |> print;
+    if n == 0 {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+
+with entry {
+    print(factorial(3));
+}

jaclang/compiler/passes/main/tests/fixtures/func2.jac

@@ -0,0 +1,8 @@
+can factorial(n: int) -> str {
+    if n == 0 {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+

jaclang/compiler/passes/main/tests/fixtures/game1.jac

@@ -0,0 +1,15 @@
+import:py random;
+import:py from typing, Tuple;
+
+obj Button {
+    can is_pressed(pos: tuple, pressed: str) -> bool {
+        return True;
+    }
+}
+
+can ttt() -> int {
+    b = Button();
+    a = random.randint(1, 10);
+    b.is_pressed((1, 2, 3), a);
+    return 0;
+}

jaclang/compiler/passes/main/tests/fixtures/impl/defs1.jac

@@ -0,0 +1,8 @@
+"""Defs for test"""
+
+:o:MyObject:c:foo() {
+    "hello" |> print;
+}
+:o:MyObject:c:bar() {
+    "hello" |> print;
+}

jaclang/compiler/passes/main/tests/fixtures/impl/defs2.jac

@@ -0,0 +1,8 @@
+"""Defs for test"""
+
+:o:MyObject:c:foo() {
+    "hello" |> print;
+}
+:o:MyObject:c:bar() {
+    "hello" |> print;
+}

jaclang/compiler/passes/main/tests/fixtures/impl/imps.jac

@@ -0,0 +1,11 @@
+"""Globals for test"""
+
+glob test_glob = 56;
+
+:o:Test:c:init {
+    "initializing" |> print;
+}
+
+:o:Test:c:say_hi {
+    "HI!" |> print;
+}