jaclang 0.7.32__tar.gz → 0.7.34__tar.gz

{jaclang-0.7.32 → jaclang-0.7.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jaclang
-Version: 0.7.32
+Version: 0.7.34
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence

{jaclang-0.7.32 → jaclang-0.7.34}/jaclang/__init__.py

@@ -23,7 +23,6 @@ from jaclang.plugin.builtin import dotgen, jid, jobj  # noqa: F401
 from jaclang.plugin.default import JacFeatureImpl
 from jaclang.plugin.feature import JacFeature as Jac, plugin_manager
 from jaclang.plugin.spec import EdgeDir
-from jaclang.runtimelib.context import ExecutionContext
 
 __all__ = [
     # Jac types.
@@ -173,7 +172,7 @@ class Node(_ArchiTypeBase, metaclass=JacMeta):
         self,
         node: "Node | Root | JacList[Node | Root]",
         edge: "type[Edge] | Edge | None" = None,
-        unidir: bool = False,
+        undir: bool = False,
         conn_assign: tuple[tuple, tuple] | None = None,
         edges_only: bool = False,
     ) -> "JacList[Node | Root| Edge]":
@@ -183,7 +182,7 @@ class Node(_ArchiTypeBase, metaclass=JacMeta):
             left=self,  # type: ignore [arg-type]
             right=node,  # type: ignore [arg-type]
             edge_spec=Jac.build_edge(
-                is_undirected=unidir, conn_type=edge, conn_assign=conn_assign  # type: ignore [arg-type]
+                is_undirected=undir, conn_type=edge, conn_assign=conn_assign  # type: ignore [arg-type]
             ),
             edges_only=edges_only,
         )
@@ -244,7 +243,7 @@ class Root(_ArchiTypeBase, metaclass=JacMeta):
         self,
         node: "Node | Root | JacList[Node | Root]",
         edge: "type[Edge] | Edge | None" = None,
-        unidir: bool = False,
+        undir: bool = False,
         conn_assign: tuple[tuple, tuple] | None = None,
         edges_only: bool = False,
     ) -> "JacList[Node | Root| Edge]":
@@ -254,7 +253,7 @@ class Root(_ArchiTypeBase, metaclass=JacMeta):
             left=self,  # type: ignore [arg-type]
             right=node,  # type: ignore [arg-type]
             edge_spec=Jac.build_edge(
-                is_undirected=unidir, conn_type=edge, conn_assign=conn_assign  # type: ignore [arg-type]
+                is_undirected=undir, conn_type=edge, conn_assign=conn_assign  # type: ignore [arg-type]
             ),
             edges_only=edges_only,
         )
@@ -416,13 +415,7 @@ def field(
 jac_test = Jac.create_test
 static = ClassVar
 
-root = cast(Root, Jac.get_root())
 
-
-# Listen to context change and update the above global root here.
-def _update_root() -> None:
-    global root
-    root = cast(Root, ExecutionContext.get_root())
-
-
-ExecutionContext.on_ctx_change.append(lambda ctx: _update_root())
+def root() -> Root:
+    """Get Root."""
+    return cast(Root, Jac.get_root())

{jaclang-0.7.32 → jaclang-0.7.34}/jaclang/compiler/parser.py

@@ -945,45 +945,24 @@ class JacParser(Pass):
                 kid=self.cur_nodes,
             )
 
-        def param_var(self, kid: list[ast.AstNode]) -> ast.ParamVar:
+        def param_var(self, _: None) -> ast.ParamVar:
             """Grammar rule.
 
             param_var: (STAR_POW | STAR_MUL)? NAME (COLON STRING)? type_tag (EQ expression)?
             """
-            star = (
-                kid[0]
-                if isinstance(kid[0], ast.Token)
-                and kid[0].name != Tok.NAME
-                and not isinstance(kid[0], ast.String)
-                else None
-            )
-            name = kid[1] if (star) else kid[0]
-            value = kid[-1] if isinstance(kid[-1], ast.Expr) else None
-            type_tag = kid[-3] if value else kid[-1]
-            semstr = (
-                kid[3]
-                if star and len(kid) > 3 and isinstance(kid[3], ast.String)
-                else (
-                    kid[2]
-                    if len(kid) > 4 and value and isinstance(kid[2], ast.String)
-                    else (
-                        kid[2]
-                        if len(kid) > 2 and isinstance(kid[2], ast.String)
-                        else None
-                    )
-                )
+            star = self.match_token(Tok.STAR_POW) or self.match_token(Tok.STAR_MUL)
+            name = self.consume(ast.Name)
+            semstr = self.match(ast.String) if self.match_token(Tok.COLON) else None
+            type_tag = self.consume(ast.SubTag)
+            value = self.consume(ast.Expr) if self.match_token(Tok.EQ) else None
+            return ast.ParamVar(
+                semstr=semstr,
+                name=name,
+                type_tag=type_tag,
+                value=value,
+                unpack=star,
+                kid=self.cur_nodes,
             )
-            if isinstance(name, ast.Name) and isinstance(type_tag, ast.SubTag):
-                return ast.ParamVar(
-                    semstr=semstr,
-                    name=name,
-                    type_tag=type_tag,
-                    value=value,
-                    unpack=star,
-                    kid=kid,
-                )
-            else:
-                raise self.ice()
 
         def member_block(self, _: None) -> ast.SubNodeList[ast.ArchBlockStmt]:
             """Grammar rule.
@@ -1002,7 +981,7 @@ class JacParser(Pass):
             ret.right_enc = right_enc
             return ret
 
-        def member_stmt(self, kid: list[ast.AstNode]) -> ast.ArchBlockStmt:
+        def member_stmt(self, _: None) -> ast.ArchBlockStmt:
             """Grammar rule.
 
             member_stmt: doc_tag? py_code_block
@@ -1011,18 +990,11 @@ class JacParser(Pass):
                         | doc_tag? architype
                         | doc_tag? has_stmt
             """
-            if isinstance(kid[0], ast.ArchBlockStmt):
-                ret = kid[0]
-            elif (
-                isinstance(kid[1], ast.ArchBlockStmt)
-                and isinstance(kid[1], ast.AstDocNode)
-                and isinstance(kid[0], ast.String)
-            ):
-                kid[1].doc = kid[0]
-                kid[1].add_kids_left([kid[0]])
-                ret = kid[1]
-            else:
-                raise self.ice()
+            doc = self.match(ast.String)
+            ret = self.consume(ast.ArchBlockStmt)
+            if doc and isinstance(ret, ast.AstDocNode):
+                ret.doc = doc
+                ret.add_kids_left([doc])
             if isinstance(ret, ast.Ability):
                 ret.signature.is_method = True
             return ret
@@ -1072,27 +1044,30 @@ class JacParser(Pass):
                 kid=new_kid,
             )
 
-        def typed_has_clause(self, kid: list[ast.AstNode]) -> ast.HasVar:
+        def typed_has_clause(self, _: None) -> ast.HasVar:
             """Grammar rule.
 
             typed_has_clause: named_ref (COLON STRING)? type_tag (EQ expression | KW_BY KW_POST_INIT)?
             """
-            name = kid[0]
-            semstr = kid[2] if len(kid) > 2 and isinstance(kid[2], ast.String) else None
-            type_tag = kid[3] if semstr else kid[1]
-            defer = isinstance(kid[-1], ast.Token) and kid[-1].name == Tok.KW_POST_INIT
-            value = kid[-1] if not defer and isinstance(kid[-1], ast.Expr) else None
-            if isinstance(name, ast.Name) and isinstance(type_tag, ast.SubTag):
-                return ast.HasVar(
-                    semstr=semstr,
-                    name=name,
-                    type_tag=type_tag,
-                    defer=defer,
-                    value=value,
-                    kid=kid,
-                )
-            else:
-                raise self.ice()
+            semstr: ast.String | None = None
+            value: ast.Expr | None = None
+            defer: bool = False
+            name = self.consume(ast.Name)
+            if self.match_token(Tok.COLON):
+                semstr = self.consume(ast.String)
+            type_tag = self.consume(ast.SubTag)
+            if self.match_token(Tok.EQ):
+                value = self.consume(ast.Expr)
+            elif self.match_token(Tok.KW_BY):
+                defer = bool(self.consume_token(Tok.KW_POST_INIT))
+            return ast.HasVar(
+                semstr=semstr,
+                name=name,
+                type_tag=type_tag,
+                defer=defer,
+                value=value,
+                kid=self.cur_nodes,
+            )
 
         def type_tag(self, _: None) -> ast.SubTag[ast.Expr]:
             """Grammar rule.
@@ -1425,21 +1400,22 @@ class JacParser(Pass):
                 kid=self.cur_nodes,
             )
 
-        def raise_stmt(self, kid: list[ast.AstNode]) -> ast.RaiseStmt:
+        def raise_stmt(self, _: None) -> ast.RaiseStmt:
             """Grammar rule.
 
             raise_stmt: KW_RAISE (expression (KW_FROM expression)?)?
             """
-            chomp = [*kid][1:]
-            e_type = (
-                chomp[0] if len(chomp) > 0 and isinstance(chomp[0], ast.Expr) else None
-            )
-            chomp = chomp[2:] if e_type and len(chomp) > 1 else chomp[1:]
-            e = chomp[0] if len(chomp) > 0 and isinstance(chomp[0], ast.Expr) else None
+            e_type: ast.Expr | None = None
+            from_target: ast.Expr | None = None
+            self.consume_token(Tok.KW_RAISE)
+            if e_type := self.match(ast.Expr):
+                from_target = (
+                    self.consume(ast.Expr) if self.match_token(Tok.KW_FROM) else None
+                )
             return ast.RaiseStmt(
                 cause=e_type,
-                from_target=e,
-                kid=kid,
+                from_target=from_target,
+                kid=self.cur_nodes,
             )
 
         def assert_stmt(self, _: None) -> ast.AssertStmt:
@@ -2233,23 +2209,19 @@ class JacParser(Pass):
                 kid=valid_parts,
             )
 
-        def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal:
+        def list_val(self, _: None) -> ast.ListVal:
             """Grammar rule.
 
             list_val: LSQUARE (expr_list COMMA?)? RSQUARE
             """
-            if len(kid) == 2:
-                return ast.ListVal(
-                    values=None,
-                    kid=kid,
-                )
-            elif isinstance(kid[1], ast.SubNodeList):
-                return ast.ListVal(
-                    values=kid[1],
-                    kid=kid,
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.LSQUARE)
+            values = self.match(ast.SubNodeList)
+            self.match_token(Tok.COMMA)
+            self.consume_token(Tok.RSQUARE)
+            return ast.ListVal(
+                values=values,
+                kid=self.cur_nodes,
+            )
 
         def tuple_val(self, _: None) -> ast.TupleVal:
             """Grammar rule.
@@ -2283,17 +2255,12 @@ class JacParser(Pass):
 
             expr_list: (expr_list COMMA)? expression
             """
-            consume = None
-            expr = None
-            comma = None
-            if isinstance(kid[0], ast.SubNodeList):
-                consume = kid[0]
-                comma = kid[1]
-                expr = kid[2]
-                new_kid = [*consume.kid, comma, expr]
-            else:
-                expr = kid[0]
-                new_kid = [expr]
+            new_kid: list = []
+            if consume := self.match(ast.SubNodeList):
+                comma = self.consume_token(Tok.COMMA)
+                new_kid.extend([*consume.kid, comma])
+            expr = self.consume(ast.Expr)
+            new_kid.extend([expr])
             valid_kid = [i for i in new_kid if isinstance(i, ast.Expr)]
             return ast.SubNodeList[ast.Expr](
                 items=valid_kid,
@@ -2320,40 +2287,36 @@ class JacParser(Pass):
                 kid=new_kid,
             )
 
-        def kw_expr(self, kid: list[ast.AstNode]) -> ast.KWPair:
+        def kw_expr(self, _: None) -> ast.KWPair:
             """Grammar rule.
 
             kw_expr: named_ref EQ expression | STAR_POW expression
             """
-            if (
-                len(kid) == 3
-                and isinstance(kid[0], ast.NameAtom)
-                and isinstance(kid[2], ast.Expr)
-            ):
-                return ast.KWPair(
-                    key=kid[0],
-                    value=kid[2],
-                    kid=kid,
-                )
-            elif len(kid) == 2 and isinstance(kid[1], ast.Expr):
-                return ast.KWPair(
-                    key=None,
-                    value=kid[1],
-                    kid=kid,
-                )
+            if self.match_token(Tok.STAR_POW):
+                value = self.consume(ast.Expr)
+                key = None
             else:
-                raise self.ice()
+                key = self.consume(ast.Name)
+                self.consume_token(Tok.EQ)
+                value = self.consume(ast.Expr)
+            return ast.KWPair(
+                key=key,
+                value=value,
+                kid=self.cur_nodes,
+            )
 
-        def name_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Name]:
+        def name_list(self, _: None) -> ast.SubNodeList[ast.Name]:
             """Grammar rule.
 
             name_list: (named_ref COMMA)* named_ref
             """
-            valid_kid = [i for i in kid if isinstance(i, ast.Name)]
+            valid_kid = [self.consume(ast.Name)]
+            while self.match_token(Tok.COMMA):
+                valid_kid.append(self.consume(ast.Name))
             return ast.SubNodeList[ast.Name](
                 items=valid_kid,
                 delim=Tok.COMMA,
-                kid=kid,
+                kid=self.cur_nodes,
             )
 
         def tuple_list(self, _: None) -> ast.SubNodeList[ast.Expr | ast.KWPair]:
@@ -2536,23 +2499,17 @@ class JacParser(Pass):
                     expr_list.kid.append(ends_comma)
                 return expr_list
 
-        def assignment_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.Assignment]:
+        def assignment_list(self, _: None) -> ast.SubNodeList[ast.Assignment]:
             """Grammar rule.
 
             assignment_list: assignment_list COMMA assignment | assignment
             """
-            consume = None
-            assign = None
-            comma = None
-            if isinstance(kid[0], ast.SubNodeList):
-                consume = kid[0]
-                comma = kid[1]
-                assign = kid[2]
+            if consume := self.match(ast.SubNodeList):
+                comma = self.consume_token(Tok.COMMA)
+                assign = self.consume(ast.Assignment)
                 new_kid = [*consume.kid, comma, assign]
             else:
-                assign = kid[0]
+                assign = self.consume(ast.Assignment)
                 new_kid = [assign]
             valid_kid = [i for i in new_kid if isinstance(i, ast.Assignment)]
             return ast.SubNodeList[ast.Assignment](
@@ -2685,93 +2642,79 @@ class JacParser(Pass):
             name = self.consume(ast.ArchRef)
             new_kid = [*consume.kid, name] if consume else [name]
             valid_kid = [i for i in new_kid if isinstance(i, ast.ArchRef)]
-            if len(valid_kid) == len(new_kid):
-                return ast.ArchRefChain(
-                    archs=valid_kid,
-                    kid=new_kid,
-                )
-            else:
-                raise self.ice()
+            return ast.ArchRefChain(
+                archs=valid_kid,
+                kid=new_kid,
+            )
 
-        def abil_to_arch_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain:
+        def abil_to_arch_chain(self, _: None) -> ast.ArchRefChain:
             """Grammar rule.
 
             abil_to_arch_chain: arch_or_ability_chain? arch_ref
             """
-            if len(kid) == 2:
-                if isinstance(kid[1], ast.ArchRef) and isinstance(
-                    kid[0], ast.ArchRefChain
-                ):
-                    return ast.ArchRefChain(
-                        archs=[*(kid[0].archs), kid[1]],
-                        kid=[*(kid[0].kid), kid[1]],
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], ast.ArchRef):
+            arch_chain = self.match(ast.ArchRefChain)
+            arch_ref = self.consume(ast.ArchRef)
+            if arch_chain:
                 return ast.ArchRefChain(
-                    archs=[kid[0]],
-                    kid=kid,
+                    archs=[*arch_chain.archs, arch_ref],
+                    kid=[*arch_chain.kid, arch_ref],
                 )
-            else:
-                raise self.ice()
+            return ast.ArchRefChain(
+                archs=[arch_ref],
+                kid=[arch_ref],
+            )
 
-        def arch_to_abil_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain:
+        def arch_to_abil_chain(self, _: None) -> ast.ArchRefChain:
             """Grammar rule.
 
             arch_to_abil_chain: arch_or_ability_chain? ability_ref
             """
-            if len(kid) == 2:
-                if isinstance(kid[1], ast.ArchRef) and isinstance(
-                    kid[0], ast.ArchRefChain
-                ):
-                    return ast.ArchRefChain(
-                        archs=[*(kid[0].archs), kid[1]],
-                        kid=[*(kid[0].kid), kid[1]],
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], ast.ArchRef):
+            arch_chain = self.match(ast.ArchRefChain)
+            abil_ref = self.consume(ast.ArchRef)
+            if arch_chain:
                 return ast.ArchRefChain(
-                    archs=[kid[0]],
-                    kid=kid,
+                    archs=[*arch_chain.archs, abil_ref],
+                    kid=[*arch_chain.kid, abil_ref],
                 )
-            else:
-                raise self.ice()
+            return ast.ArchRefChain(
+                archs=[abil_ref],
+                kid=[abil_ref],
+            )
 
-        def arch_to_enum_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain:
+        def arch_to_enum_chain(self, _: None) -> ast.ArchRefChain:
             """Grammar rule.
 
             arch_to_enum_chain: arch_or_ability_chain? enum_ref
             """
-            if len(kid) == 2:
-                if isinstance(kid[1], ast.ArchRef) and isinstance(
-                    kid[0], ast.ArchRefChain
-                ):
-                    return ast.ArchRefChain(
-                        archs=[*(kid[0].archs), kid[1]],
-                        kid=[*(kid[0].kid), kid[1]],
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], ast.ArchRef):
+            arch_chain = self.match(ast.ArchRefChain)
+            enum_ref = self.consume(ast.ArchRef)
+            if arch_chain:
                 return ast.ArchRefChain(
-                    archs=[kid[0]],
-                    kid=kid,
+                    archs=[*arch_chain.archs, enum_ref],
+                    kid=[*arch_chain.kid, enum_ref],
                 )
-            else:
-                raise self.ice()
+            return ast.ArchRefChain(
+                archs=[enum_ref],
+                kid=[enum_ref],
+            )
 
-        def edge_ref_chain(self, kid: list[ast.AstNode]) -> ast.EdgeRefTrailer:
+        def edge_ref_chain(self, _: None) -> ast.EdgeRefTrailer:
             """Grammar rule.
 
             (EDGE_OP|NODE_OP)? LSQUARE expression? (edge_op_ref (filter_compr | expression)?)+ RSQUARE
             """
-            valid_chain = [i for i in kid if isinstance(i, (ast.Expr, ast.FilterCompr))]
+            edges_only = bool(self.match_token(Tok.EDGE_OP))
+            self.match_token(Tok.NODE_OP)
+            self.consume_token(Tok.LSQUARE)
+            valid_chain = []
+            if expr := self.match(ast.Expr):
+                valid_chain.append(expr)
+            valid_chain.extend(self.match_many(ast.Expr))
+            self.consume_token(Tok.RSQUARE)
             return ast.EdgeRefTrailer(
                 chain=valid_chain,
-                edges_only=isinstance(kid[0], ast.Token) and kid[0].name == Tok.EDGE_OP,
-                kid=kid,
+                edges_only=edges_only,
+                kid=self.cur_nodes,
             )
 
         def edge_op_ref(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef:
@@ -2987,27 +2930,16 @@ class JacParser(Pass):
                 kid=new_kid,
             )
 
-        def typed_filter_compare_list(self, kid: list[ast.AstNode]) -> ast.FilterCompr:
+        def typed_filter_compare_list(self, _: None) -> 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 ast.FilterCompr(compares=compares, f_type=expr, kid=kid)
-            else:
-                raise self.ice()
+            compares: ast.SubNodeList | None = None
+            expr = self.consume(ast.Expr)
+            if self.match_token(Tok.COLON):
+                compares = self.consume(ast.SubNodeList)
+            return ast.FilterCompr(compares=compares, f_type=expr, kid=self.cur_nodes)
 
         def filter_compare_item(self, _: None) -> ast.CompareExpr:
             """Grammar rule.

{jaclang-0.7.32 → jaclang-0.7.34}/jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -2937,7 +2937,15 @@ class PyastGenPass(Pass):
                 )
             ]
         elif node.name == Tok.KW_ROOT:
-            node.gen.py_ast = [self.jaclib_obj("root")]
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.jaclib_obj("root"),
+                        args=[],
+                        keywords=[],
+                    )
+                )
+            ]
 
         else:
             node.gen.py_ast = [
@@ -3118,7 +3126,7 @@ class PyastGenPass(Pass):
                 self.sync(
                     ast3.keyword(
                         arg="target",
-                        value=self.sync(ast3.Constant(value=None)),
+                        value=targ,
                     )
                 )
             )

{jaclang-0.7.32 → jaclang-0.7.34}/jaclang/runtimelib/context.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import unittest
 from contextvars import ContextVar
 from dataclasses import MISSING
-from typing import Any, Callable, ClassVar, Optional, cast
+from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
 from .architype import NodeAnchor, Root
@@ -26,9 +26,6 @@ class ExecutionContext:
     root: NodeAnchor
     entry_node: NodeAnchor
 
-    # A context change event subscription list, those who want to listen ctx change will register here.
-    on_ctx_change: ClassVar[list[Callable[[ExecutionContext | None], None]]] = []
-
     def init_anchor(
         self,
         anchor_id: str | None,
@@ -49,8 +46,6 @@ class ExecutionContext:
         """Close current ExecutionContext."""
         self.mem.close()
         EXECUTION_CONTEXT.set(None)
-        for func in ExecutionContext.on_ctx_change:
-            func(EXECUTION_CONTEXT.get(None))
 
     @staticmethod
     def create(
@@ -80,8 +75,6 @@ class ExecutionContext:
             old_ctx.close()
 
         EXECUTION_CONTEXT.set(ctx)
-        for func in ExecutionContext.on_ctx_change:
-            func(EXECUTION_CONTEXT.get(None))
 
         return ctx
 

{jaclang-0.7.32 → jaclang-0.7.34}/jaclang/tests/fixtures/disconn.jac

@@ -16,7 +16,7 @@ with entry{
     x=[a(aa=x) for x in range(0,3)];
     y=[b(bb=x) for x in range(0,3)];
     z=[c(cc=x) for x in range(0,3)];
-    x++>y;
+    x<++>y; # just adding one trigger of undirected connect
     y++>z;
     apple: int;
     # print(x -:aaa:-> );

jaclang-0.7.34/jaclang/tests/fixtures/refs_target.jac

@@ -0,0 +1,17 @@
+
+node a { has val:int=0; }
+node b { has val:int=0; }
+node c { has val:int=0; }
+
+with entry {
+
+    x = [a(val=i) for i in range(0,3)];
+    y = [b(val=i) for i in range(0,3)];
+    z = [c(val=i) for i in range(0,3)];
+
+    x ++> y;
+    y ++> z;
+
+    print([x-->y-->z]);  # [c(val=0), c(val=1), c(val=2)]
+    print([x-->y[:1]-->z[:1]]); # [c(val=0)]
+}

{jaclang-0.7.32 → jaclang-0.7.34}/jaclang/tests/test_language.py

@@ -694,6 +694,19 @@ class JacLanguageTests(TestCase):
         self.assertIn(" case Point(x = int(_), y = 0):\n", output)
         self.assertIn("class Sample {\n    can init", output)
 
+    def test_refs_target(self) -> None:
+        """
+        This test added after a bug in jaclib Node.refs() wasn't code gen as expected and it
+        wasn't captured with the tests.
+        """
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("refs_target", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("[c(val=0), c(val=1), c(val=2)]", stdout_value)
+        self.assertIn("[c(val=0)]", stdout_value)
+
     def test_py_kw_as_name_disallowed(self) -> None:
         """Basic precedence test."""
         prog = jac_str_to_pass("with entry {print.is.not.True(4-5-4);}", "test.jac")