jaclang 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -1300,7 +1300,7 @@ class BinaryExpr(Expr):
 
 
 class CompareExpr(Expr):
-    """ExprBinary node type for Jac Ast."""
+    """CompareExpr node type for Jac Ast."""
 
     def __init__(
         self,
@@ -1316,6 +1316,21 @@ class CompareExpr(Expr):
         AstNode.__init__(self, kid=kid)
 
 
+class BoolExpr(Expr):
+    """BoolExpr node type for Jac Ast."""
+
+    def __init__(
+        self,
+        op: Token,
+        values: list[Expr],
+        kid: Sequence[AstNode],
+    ) -> None:
+        """Initialize binary expression node."""
+        self.values = values
+        self.op = op
+        AstNode.__init__(self, kid=kid)
+
+
 class LambdaExpr(Expr):
     """ExprLambda node type for Jac Ast."""
 
@@ -1764,13 +1779,11 @@ class EdgeOpRef(WalkerStmtOnlyNode, AtomExpr):
 
     def __init__(
         self,
-        filter_type: Optional[Expr],
         filter_cond: Optional[FilterCompr],
         edge_dir: EdgeDir,
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize edge op reference expression node."""
-        self.filter_type = filter_type
         self.filter_cond = filter_cond
         self.edge_dir = edge_dir
         AstNode.__init__(self, kid=kid)
@@ -1819,10 +1832,12 @@ class FilterCompr(AtomExpr):
 
     def __init__(
         self,
-        compares: SubNodeList[CompareExpr],
+        f_type: Optional[Expr],
+        compares: Optional[SubNodeList[CompareExpr]],
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize filter_cond context expression node."""
+        self.f_type = f_type
         self.compares = compares
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(

jaclang/compiler/parser.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import Callable, TypeAlias, cast
+from typing import Callable, TypeAlias
 
 
 import jaclang.compiler.absyntree as ast
@@ -1915,16 +1915,48 @@ class JacParser(Pass):
         def logical_or(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            logical_or: (logical_or KW_OR)? logical_and
+            logical_or: logical_and (KW_OR logical_and)*
             """
-            return self.binary_expr_unwind(kid)
+            if len(kid) > 1:
+                values = [i for i in kid if isinstance(i, ast.Expr)]
+                ops = kid[1] if isinstance(kid[1], ast.Token) else None
+                if not ops:
+                    raise self.ice()
+                return self.nu(
+                    ast.BoolExpr(
+                        op=ops,
+                        values=values,
+                        kid=kid,
+                    )
+                )
+            elif isinstance(kid[0], ast.Expr):
+                return self.nu(kid[0])
+            else:
+
+                raise self.ice()
 
         def logical_and(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
-            logical_and: (logical_and KW_AND)? logical_not
+            logical_and: logical_not (KW_AND logical_not)*
             """
-            return self.binary_expr_unwind(kid)
+            if len(kid) > 1:
+                values = [i for i in kid if isinstance(i, ast.Expr)]
+                ops = kid[1] if isinstance(kid[1], ast.Token) else None
+                if not ops:
+                    raise self.ice()
+                return self.nu(
+                    ast.BoolExpr(
+                        op=ops,
+                        values=values,
+                        kid=kid,
+                    )
+                )
+            elif isinstance(kid[0], ast.Expr):
+                return self.nu(kid[0])
+            else:
+
+                raise self.ice()
 
         def logical_not(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
@@ -2224,76 +2256,51 @@ class JacParser(Pass):
             else:
                 raise self.ice()
 
-        def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice | ast.ListVal:
+        def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice:
             """Grammar rule.
 
             index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
-                       | list_val
-            """
-            if len(kid) == 1 and isinstance(kid[0], ast.ListVal):
-                expr = None
-                if not kid[0].values or len(kid[0].values.items) < 1:
-                    self.parse_ref.error("Empty list slice not allowed", kid[0].values)
-                elif len(kid[0].values.items) == 1:
-                    expr = kid[0].values.items[0]  # TODO: Loses braces
+                    | list_val
+            """
+            if len(kid) == 1:
+                index = kid[0]
+                if isinstance(index, ast.ListVal):
+                    expr = index.values.items[0] if index.values else None
+                    return self.nu(
+                        ast.IndexSlice(
+                            start=expr,
+                            stop=None,
+                            step=None,
+                            is_range=False,
+                            kid=kid[0].kid,
+                        )
+                    )
                 else:
-                    vals = cast("ast.SubNodeList[ast.Expr|ast.KWPair]", kid[0].values)
-                    expr = ast.TupleVal(values=vals, kid=kid[0].kid)
-                if expr is None:
                     raise self.ice()
-                return self.nu(
-                    ast.IndexSlice(
-                        start=expr, stop=None, step=None, is_range=False, kid=[expr]
-                    )
-                )
-            chomp = [*kid]
-            chomp = chomp[1:]
-            expr1 = chomp[0] if isinstance(chomp[0], ast.Expr) else None
-            expr2 = (
-                chomp[1]
-                if isinstance(chomp[0], ast.Token)
-                and chomp[0].name == Tok.COLON
-                and isinstance(chomp[1], ast.Expr)
-                else None
-            )
-            chomp = chomp[1:]
-            expr2 = (
-                chomp[1]
-                if isinstance(chomp[0], ast.Token)
-                and chomp[0].name == Tok.COLON
-                and len(chomp) > 1
-                and isinstance(chomp[1], ast.Expr)
-                else expr2
-            )
-            expr3 = None
-            if len(chomp) > 1:
+            else:
+                expr1 = expr2 = expr3 = None
+                chomp = kid[1:]
+                if isinstance(chomp[0], ast.Expr):
+                    expr1 = chomp[0]
+                    chomp = chomp[1:]
                 chomp = chomp[1:]
-                expr3 = (
-                    chomp[1]
-                    if isinstance(chomp[0], ast.Token)
-                    and chomp[0].name == Tok.COLON
-                    and isinstance(chomp[1], ast.Expr)
-                    else None
-                )
-                if len(chomp) > 1:
+                if isinstance(chomp[0], ast.Expr):
+                    expr2 = chomp[0]
+                    chomp = chomp[1:]
+                if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COLON:
                     chomp = chomp[1:]
-                    expr3 = (
-                        chomp[1]
-                        if isinstance(chomp[0], ast.Token)
-                        and chomp[0].name == Tok.COLON
-                        and len(chomp) > 1
-                        and isinstance(chomp[1], ast.Expr)
-                        else expr3
+                    if isinstance(chomp[0], ast.Expr):
+                        expr3 = chomp[0]
+                        chomp = chomp[1:]
+                return self.nu(
+                    ast.IndexSlice(
+                        start=expr1,
+                        stop=expr2,
+                        step=expr3,
+                        is_range=True,
+                        kid=kid,
                     )
-            return self.nu(
-                ast.IndexSlice(
-                    start=expr1,
-                    stop=expr2,
-                    step=expr3,
-                    is_range=True,
-                    kid=kid,
                 )
-            )
 
         def atom(self, kid: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
@@ -3128,24 +3135,13 @@ class JacParser(Pass):
         def edge_to(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef:
             """Grammar rule.
 
-            edge_to: ARROW_R_P1 expression (COLON filter_compare_list)? ARROW_R_P2
+            edge_to: ARROW_R_P1 typed_filter_compare_list ARROW_R_P2
                    | ARROW_R
             """
-            ftype = kid[1] if len(kid) >= 3 else None
-            fcond = kid[3] if len(kid) >= 5 else None
-            if (isinstance(ftype, ast.Expr) or ftype is None) and (
-                isinstance(fcond, ast.SubNodeList) or fcond is None
-            ):
-                fcond = ast.FilterCompr(compares=fcond, kid=[fcond]) if fcond else None
-                if fcond:
-                    kid[3] = fcond
+            fcond = kid[1] if len(kid) > 1 else None
+            if isinstance(fcond, ast.FilterCompr) or fcond is None:
                 return self.nu(
-                    ast.EdgeOpRef(
-                        filter_type=ftype,
-                        filter_cond=fcond,
-                        edge_dir=EdgeDir.OUT,
-                        kid=kid,
-                    )
+                    ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.OUT, kid=kid)
                 )
             else:
                 raise self.ice()
@@ -3153,24 +3149,13 @@ class JacParser(Pass):
         def edge_from(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef:
             """Grammar rule.
 
-            edge_from: ARROW_L_P1 expression (COLON filter_compare_list)? ARROW_L_P2
+            edge_from: ARROW_L_P1 typed_filter_compare_list ARROW_L_P2
                      | ARROW_L
             """
-            ftype = kid[1] if len(kid) >= 3 else None
-            fcond = kid[3] if len(kid) >= 5 else None
-            if (isinstance(ftype, ast.Expr) or ftype is None) and (
-                isinstance(fcond, ast.SubNodeList) or fcond is None
-            ):
-                fcond = ast.FilterCompr(compares=fcond, kid=[fcond]) if fcond else None
-                if fcond:
-                    kid[3] = fcond
+            fcond = kid[1] if len(kid) > 1 else None
+            if isinstance(fcond, ast.FilterCompr) or fcond is None:
                 return self.nu(
-                    ast.EdgeOpRef(
-                        filter_type=ftype,
-                        filter_cond=fcond,
-                        edge_dir=EdgeDir.IN,
-                        kid=kid,
-                    )
+                    ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.IN, kid=kid)
                 )
             else:
                 raise self.ice()
@@ -3178,24 +3163,13 @@ class JacParser(Pass):
         def edge_any(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef:
             """Grammar rule.
 
-            edge_any: ARROW_L_P1 expression (COLON filter_compare_list)? ARROW_R_P2
+            edge_any: ARROW_L_P1 typed_filter_compare_list ARROW_R_P2
                     | ARROW_BI
             """
-            ftype = kid[1] if len(kid) >= 3 else None
-            fcond = kid[3] if len(kid) >= 5 else None
-            if (isinstance(ftype, ast.Expr) or ftype is None) and (
-                isinstance(fcond, ast.SubNodeList) or fcond is None
-            ):
-                fcond = ast.FilterCompr(compares=fcond, kid=[fcond]) if fcond else None
-                if fcond:
-                    kid[3] = fcond
+            fcond = kid[1] if len(kid) > 1 else None
+            if isinstance(fcond, ast.FilterCompr) or fcond is None:
                 return self.nu(
-                    ast.EdgeOpRef(
-                        filter_type=ftype,
-                        filter_cond=fcond,
-                        edge_dir=EdgeDir.ANY,
-                        kid=kid,
-                    )
+                    ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.ANY, kid=kid)
                 )
             else:
                 raise self.ice()
@@ -3314,15 +3288,15 @@ class JacParser(Pass):
         def filter_compr(self, kid: list[ast.AstNode]) -> ast.FilterCompr:
             """Grammar rule.
 
-            filter_compr: LPAREN EQ filter_compare_list RPAREN
+            filter_compr: LPAREN NULL_OK filter_compare_list RPAREN
+                        | LPAREN TYPE_OP NULL_OK typed_filter_compare_list RPAREN
             """
             if isinstance(kid[2], ast.SubNodeList):
-                return self.nu(
-                    ast.FilterCompr(
-                        compares=kid[2],
-                        kid=kid,
-                    )
-                )
+                return self.nu(ast.FilterCompr(compares=kid[2], f_type=None, kid=kid))
+            elif isinstance(kid[3], ast.FilterCompr):
+                kid[3].add_kids_left(kid[:3])
+                kid[3].add_kids_right(kid[4:])
+                return self.nu(kid[3])
             else:
                 raise self.ice()
 
@@ -3352,6 +3326,28 @@ class JacParser(Pass):
                 )
             )
 
+        def typed_filter_compare_list(self, kid: list[ast.AstNode]) -> ast.FilterCompr:
+            """Grammar rule.
+
+            typed_filter_compare_list: expression (COLON filter_compare_list)?
+            """
+            chomp = [*kid]
+            expr = chomp[0]
+            chomp = chomp[1:]
+            compares = (
+                chomp[1]
+                if len(chomp)
+                and isinstance(chomp[0], ast.Token)
+                and chomp[0].name == Tok.COLON
+                else None
+            )
+            if isinstance(expr, ast.Expr) and (
+                (isinstance(compares, ast.SubNodeList)) or compares is None
+            ):
+                return self.nu(ast.FilterCompr(compares=compares, f_type=expr, kid=kid))
+            else:
+                raise self.ice()
+
         def filter_compare_item(self, kid: list[ast.AstNode]) -> ast.CompareExpr:
             """Grammar rule.
 

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -1788,11 +1788,6 @@ class PyastGenPass(Pass):
                             self.sync(
                                 ast3.Constant(value=node.op.edge_spec.edge_dir.name)
                             ),
-                            (
-                                node.op.edge_spec.filter_type.gen.py_ast[0]
-                                if node.op.edge_spec.filter_type is not None
-                                else self.sync(ast3.Constant(value=None))
-                            ),
                             (
                                 node.op.edge_spec.filter_cond.gen.py_ast[0]
                                 if node.op.edge_spec.filter_cond is not None
@@ -1934,6 +1929,21 @@ class PyastGenPass(Pass):
             )
         ]
 
+    def exit_bool_expr(self, node: ast.BoolExpr) -> None:
+        """Sub objects.
+
+        op: Token,
+        values: list[Expr],
+        """
+        node.gen.py_ast = [
+            self.sync(
+                ast3.BoolOp(
+                    op=node.op.gen.py_ast[0],
+                    values=[i.gen.py_ast[0] for i in node.values],
+                )
+            )
+        ]
+
     def exit_lambda_expr(self, node: ast.LambdaExpr) -> None:
         """Sub objects.
 
@@ -2405,9 +2415,9 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Slice(
-                        lower=node.start.gen.py_ast if node.start else None,
-                        upper=node.stop.gen.py_ast if node.stop else None,
-                        step=node.step.gen.py_ast if node.step else None,
+                        lower=node.start.gen.py_ast[0] if node.start else None,
+                        upper=node.stop.gen.py_ast[0] if node.stop else None,
+                        step=node.step.gen.py_ast[0] if node.step else None,
                     )
                 )
             ]
@@ -2535,16 +2545,6 @@ class PyastGenPass(Pass):
                             ),
                         )
                     ),
-                    self.sync(
-                        ast3.keyword(
-                            arg="filter_type",
-                            value=self.sync(
-                                node.filter_type.gen.py_ast[0]
-                                if node.filter_type
-                                else self.sync(ast3.Constant(value=None))
-                            ),
-                        )
-                    ),
                     self.sync(
                         ast3.keyword(
                             arg="filter_func",
@@ -2655,38 +2655,76 @@ class PyastGenPass(Pass):
                                         iter=self.sync(
                                             ast3.Name(id="x", ctx=ast3.Load())
                                         ),
-                                        ifs=[
-                                            self.sync(
-                                                ast3.Compare(
-                                                    left=self.sync(
-                                                        ast3.Attribute(
-                                                            value=self.sync(
+                                        ifs=(
+                                            (
+                                                [
+                                                    self.sync(
+                                                        ast3.Call(
+                                                            func=self.sync(
                                                                 ast3.Name(
-                                                                    id="i",
+                                                                    id="isinstance",
                                                                     ctx=ast3.Load(),
+                                                                )
+                                                            ),
+                                                            args=[
+                                                                self.sync(
+                                                                    ast3.Name(
+                                                                        id="i",
+                                                                        ctx=ast3.Load(),
+                                                                    )
+                                                                ),
+                                                                self.sync(
+                                                                    node.f_type.gen.py_ast[
+                                                                        0
+                                                                    ]
                                                                 ),
-                                                                jac_node=x,
+                                                            ],
+                                                            keywords=[],
+                                                        )
+                                                    )
+                                                ]
+                                                if node.f_type
+                                                else []
+                                            )
+                                            + [
+                                                self.sync(
+                                                    ast3.Compare(
+                                                        left=self.sync(
+                                                            ast3.Attribute(
+                                                                value=self.sync(
+                                                                    ast3.Name(
+                                                                        id="i",
+                                                                        ctx=ast3.Load(),
+                                                                    ),
+                                                                    jac_node=x,
+                                                                ),
+                                                                attr=x.gen.py_ast[
+                                                                    0
+                                                                ].left.id,
+                                                                ctx=ast3.Load(),
                                                             ),
-                                                            attr=x.gen.py_ast[
-                                                                0
-                                                            ].left.id,
-                                                            ctx=ast3.Load(),
+                                                            jac_node=x,
                                                         ),
-                                                        jac_node=x,
+                                                        ops=x.gen.py_ast[0].ops,
+                                                        comparators=x.gen.py_ast[
+                                                            0
+                                                        ].comparators,
                                                     ),
-                                                    ops=x.gen.py_ast[0].ops,
-                                                    comparators=x.gen.py_ast[
-                                                        0
-                                                    ].comparators,
-                                                ),
-                                                jac_node=x,
-                                            )
-                                            for x in node.compares.items
-                                            if isinstance(x.gen.py_ast[0], ast3.Compare)
-                                            and isinstance(
-                                                x.gen.py_ast[0].left, ast3.Name
-                                            )
-                                        ],
+                                                    jac_node=x,
+                                                )
+                                                for x in (
+                                                    node.compares.items
+                                                    if node.compares
+                                                    else []
+                                                )
+                                                if isinstance(
+                                                    x.gen.py_ast[0], ast3.Compare
+                                                )
+                                                and isinstance(
+                                                    x.gen.py_ast[0].left, ast3.Name
+                                                )
+                                            ]
+                                        ),
                                         is_async=0,
                                     )
                                 )

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -1015,6 +1015,13 @@ class SymTabBuildPass(SymTabPass):
         """
         self.sync_node_to_scope(node)
 
+    def enter_bool_expr(self, node: ast.BoolExpr) -> None:
+        """Sub objects.
+
+        value: Token,
+        """
+        self.sync_node_to_scope(node)
+
     def enter_lambda_expr(self, node: ast.LambdaExpr) -> None:
         """Sub objects.
 

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -24,11 +24,14 @@ class JacFormatPass(Pass):
         """Return string for indent."""
         return " " * self.indent_size * self.indent_level
 
-    def emit(self, node: ast.AstNode, s: str) -> None:
+    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())
         if "\n" in node.gen.jac:
-            node.gen.jac = node.gen.jac.rstrip(" ")
+            if strip_mode:
+                node.gen.jac = node.gen.jac.rstrip(" ")
+            else:
+                node.gen.jac = node.gen.jac
 
     def emit_ln(self, node: ast.AstNode, s: str) -> None:
         """Emit code to node."""
@@ -847,20 +850,11 @@ class JacFormatPass(Pass):
                     and isinstance(node.right, ast.TupleVal)
                 )
             ):
-                # Check if line break is needed
-                if node.op.value in ["and", "or"] and self.is_line_break_needed(
-                    f"{node.left.gen.jac} {node.op.value} {node.right.gen.jac}"
-                ):
-                    self.emit_ln(node, f"{node.left.gen.jac}")
-                    self.emit(
-                        node,
-                        f"    {node.op.value} {node.right.gen.jac}",
-                    )
-                else:
-                    self.emit(
-                        node,
-                        f"{node.left.gen.jac} {node.op.value} {node.right.gen.jac}",
-                    )
+
+                self.emit(
+                    node,
+                    f"{node.left.gen.jac} {node.op.value} {node.right.gen.jac}",
+                )
             else:
                 self.error(
                     f"Binary operator {node.op.value} not supported in bootstrap Jac"
@@ -1332,6 +1326,35 @@ class JacFormatPass(Pass):
             f"Unable to find definition for {decl} declaration. Perhaps there's an `include` missing?"  # noqa
         )
 
+    def exit_bool_expr(self, node: ast.BoolExpr) -> None:
+        """Sub objects.
+
+        op: Token,
+        values: list[Expr],
+        """
+        end = node.values[-1]
+        test_str = ""
+        for i in node.values:
+            test_str += f"{i.gen.jac}"
+            if i != end:
+                test_str += f" {node.op.value} "
+
+        # Check if line break is needed
+        if self.is_line_break_needed(test_str):
+            for i in node.values:
+                if i != end:
+                    self.emit_ln(node, f"{i.gen.jac}")
+                else:
+                    self.emit(node, f"{i.gen.jac}")
+                if i != end:
+                    self.emit(
+                        node,
+                        " " * self.indent_size + f"{node.op.value} ",
+                        strip_mode=False,
+                    )
+        else:
+            self.emit(node, test_str)
+
     def exit_lambda_expr(self, node: ast.LambdaExpr) -> None:
         """Sub objects.
 
@@ -1410,11 +1433,7 @@ class JacFormatPass(Pass):
         stop: Optional[ExprType],
         """
         for i in node.kid:
-            if not i.gen.jac.startswith("["):
-                self.emit(node, "[")
             self.emit(node, i.gen.jac)
-        if not i.gen.jac.endswith("]"):
-            self.emit(node, "]")
 
     def exit_list_val(self, node: ast.ListVal) -> None:
         """Sub objects.

jaclang/compiler/tests/fixtures/__jac_gen__/hello_world.py

@@ -0,0 +1,5 @@
+""" Basic Hello World function """
+from __future__ import annotations
+
+def hello() -> None:
+    return 'Hello World!'