jaclang 0.7.25__py3-none-any.whl → 0.7.26__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as ast3
 import builtins
 import os
+from dataclasses import dataclass
 from hashlib import md5
 from types import EllipsisType
 from typing import (
@@ -3401,18 +3402,22 @@ class FuncCall(Expr):
 class IndexSlice(AtomExpr):
     """IndexSlice node type for Jac Ast."""
 
+    @dataclass
+    class Slice:
+        """Slice node for index slice."""
+
+        start: Optional[Expr]
+        stop: Optional[Expr]
+        step: Optional[Expr]
+
     def __init__(
         self,
-        start: Optional[Expr],
-        stop: Optional[Expr],
-        step: Optional[Expr],
+        slices: list[Slice],
         is_range: bool,
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize index slice expression node."""
-        self.start = start
-        self.stop = stop
-        self.step = step
+        self.slices = slices
         self.is_range = is_range
         AstNode.__init__(self, kid=kid)
         Expr.__init__(self)
@@ -3422,22 +3427,26 @@ class IndexSlice(AtomExpr):
         """Normalize ast node."""
         res = True
         if deep:
-            res = self.start.normalize(deep) if self.start else res
-            res = res and self.stop.normalize(deep) if self.stop else res
-            res = res and self.step.normalize(deep) if self.step else res
+            for slice in self.slices:
+                res = slice.start.normalize(deep) if slice.start else res
+                res = res and slice.stop.normalize(deep) if slice.stop else res
+                res = res and slice.step.normalize(deep) if slice.step else res
         new_kid: list[AstNode] = []
         new_kid.append(self.gen_token(Tok.LSQUARE))
         if self.is_range:
-            if self.start:
-                new_kid.append(self.start)
-            if self.stop:
+            for i, slice in enumerate(self.slices):
+                if i > 0:
+                    new_kid.append(self.gen_token(Tok.COMMA))
+                if slice.start:
+                    new_kid.append(slice.start)
                 new_kid.append(self.gen_token(Tok.COLON))
-                new_kid.append(self.stop)
-            if self.step:
-                new_kid.append(self.gen_token(Tok.COLON))
-                new_kid.append(self.step)
-        elif self.start:
-            new_kid.append(self.start)
+                if slice.stop:
+                    new_kid.append(slice.stop)
+                if slice.step:
+                    new_kid.append(self.gen_token(Tok.COLON))
+                    new_kid.append(slice.step)
+        elif len(self.slices) == 1 and self.slices[0].start:
+            new_kid.append(self.slices[0].start)
         else:
             res = False
         new_kid.append(self.gen_token(Tok.RSQUARE))

jaclang/compiler/jac.lark

@@ -358,7 +358,10 @@ atomic_chain: atomic_chain NULL_OK? (filter_compr | assign_compr | index_slice)
             | atomic_chain NULL_OK? (DOT_BKWD | DOT_FWD | DOT) named_ref
             | (atomic_call | atom | edge_ref_chain)
 
-index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
+index_slice: LSQUARE                                                             \
+                     expression? COLON expression? (COLON expression?)?          \
+                     (COMMA expression? COLON expression? (COLON expression?)?)* \
+              RSQUARE
            | list_val
 
 // Function calls

jaclang/compiler/parser.py

@@ -2436,8 +2436,11 @@ class JacParser(Pass):
         def index_slice(self, kid: list[ast.AstNode]) -> ast.IndexSlice:
             """Grammar rule.
 
-            index_slice: LSQUARE expression? COLON expression? (COLON expression?)? RSQUARE
-                    | list_val
+            index_slice: LSQUARE                                                        \
+                            expression? COLON expression? (COLON expression?)?          \
+                            (COMMA expression? COLON expression? (COLON expression?)?)* \
+                         RSQUARE
+                        | list_val
             """
             if len(kid) == 1:
                 index = kid[0]
@@ -2454,9 +2457,9 @@ class JacParser(Pass):
                         kid = [expr]
                     return self.nu(
                         ast.IndexSlice(
-                            start=expr,
-                            stop=None,
-                            step=None,
+                            slices=[
+                                ast.IndexSlice.Slice(start=expr, stop=None, step=None)
+                            ],
                             is_range=False,
                             kid=kid,
                         )
@@ -2464,25 +2467,39 @@ class JacParser(Pass):
                 else:
                     raise self.ice()
             else:
-                expr1 = expr2 = expr3 = None
+                slices: list[ast.IndexSlice.Slice] = []
                 chomp = kid[1:]
-                if isinstance(chomp[0], ast.Expr):
-                    expr1 = chomp[0]
-                    chomp = chomp[1:]
-                chomp = 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:]
+
+                while not (
+                    isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.RSQUARE
+                ):
+                    expr1 = expr2 = expr3 = None
+
                     if isinstance(chomp[0], ast.Expr):
-                        expr3 = chomp[0]
-                        chomp = chomp[1:]
+                        expr1 = chomp[0]
+                        chomp.pop(0)
+                    chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Expr):
+                        expr2 = chomp[0]
+                        chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COLON:
+                        chomp.pop(0)
+                        if isinstance(chomp[0], ast.Expr):
+                            expr3 = chomp[0]
+                            chomp.pop(0)
+
+                    if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.COMMA:
+                        chomp.pop(0)
+
+                    slices.append(
+                        ast.IndexSlice.Slice(start=expr1, stop=expr2, step=expr3)
+                    )
+
                 return self.nu(
                     ast.IndexSlice(
-                        start=expr1,
-                        stop=expr2,
-                        step=expr3,
+                        slices=slices,
                         is_range=True,
                         kid=kid,
                     )

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -7,6 +7,7 @@ body field.
 """
 
 import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass
 from jaclang.compiler.symtable import Symbol, SymbolTable
@@ -129,19 +130,55 @@ class DeclImplMatchPass(Pass):
                         valid_decl.name_spec,
                     )
                 else:
+                    # Copy the parameter names from the declaration to the definition.
                     for idx in range(len(params_defn.items)):
-                        # Check if all the parameter names are matched.
-                        # TODO: This shouldn't be an issue however if the names are not matched, it doesn't
-                        # work as expected like in C++, for now I'm adding this validation, however this
-                        # needs to be fixed to have a C++ style.
-                        param_name_decl = params_decl.items[idx].name.value
-                        param_name_defn = params_defn.items[idx].name.value
-                        if param_name_defn != param_name_decl:
-                            self.error(
-                                f"Parameter name mismatch for ability {sym.sym_name}.",
-                                params_defn.items[idx].name,
-                            )
+                        params_decl.items[idx] = params_defn.items[idx]
+                    for idx in range(len(params_defn.kid)):
+                        params_decl.kid[idx] = params_defn.kid[idx]
+
+    def exit_architype(self, node: ast.Architype) -> None:
+        """Exit Architype."""
+        if node.arch_type.name == Tok.KW_OBJECT and isinstance(
+            node.body, ast.SubNodeList
+        ):
+
+            found_default_init = False
+            for stmnt in node.body.items:
+                if not isinstance(stmnt, ast.ArchHas):
+                    continue
+                for var in stmnt.vars.items:
+                    if (var.value is not None) or (var.defer):
+                        found_default_init = True
+                    else:
+                        if found_default_init:
                             self.error(
-                                f"From the declaration of {valid_decl.name_spec.sym_name}.",
-                                params_decl.items[idx].name,
+                                f"Non default attribute '{var.name.value}' follows default attribute",
+                                node_override=var.name,
                             )
+                            break
+
+            post_init_vars: list[ast.HasVar] = []
+            postinit_method: ast.Ability | None = None
+
+            for item in node.body.items:
+
+                if isinstance(item, ast.ArchHas):
+                    for var in item.vars.items:
+                        if var.defer:
+                            post_init_vars.append(var)
+
+                elif isinstance(item, ast.Ability):
+                    if item.is_abstract:
+                        continue
+                    if (
+                        isinstance(item.name_ref, ast.SpecialVarRef)
+                        and item.name_ref.name == "KW_POST_INIT"
+                    ):
+                        postinit_method = item
+
+            # Check if postinit needed and not provided.
+            if len(post_init_vars) != 0 and (postinit_method is None):
+                self.error(
+                    'Missing "postinit" method required by un initialized attribute(s).',
+                    node_override=post_init_vars[0].name_spec,
+                )  # We show the error on the first uninitialized var.

jaclang/compiler/passes/main/def_use_pass.py

@@ -156,8 +156,7 @@ class DefUsePass(Pass):
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
+        slices: list[Slice],
         is_range: bool,
         """
 

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -1055,14 +1055,7 @@ class PyastGenPass(Pass):
                                 ctx=ast3.Load(),
                             )
                         ),
-                        args=[
-                            self.sync(ast3.Constant(value=i.sym_name)),
-                            (
-                                i.signature.arch_tag_info.gen.py_ast[0]
-                                if i.signature.arch_tag_info
-                                else self.sync(ast3.Constant(value=None))
-                            ),
-                        ],
+                        args=[self.sync(ast3.Constant(value=i.sym_name))],
                         keywords=[],
                     )
                 )
@@ -3081,23 +3074,56 @@ class PyastGenPass(Pass):
     def exit_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
-        step: Optional[ExprType],
+        slices: list[IndexSlice.Slice],
         is_range: bool,
         """
         if node.is_range:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.Slice(
-                        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,
+            if len(node.slices) > 1:  # Multiple slices. Example arr[a:b, c:d]
+                node.gen.py_ast = [
+                    self.sync(
+                        ast3.Tuple(
+                            elts=[
+                                self.sync(
+                                    ast3.Slice(
+                                        lower=(
+                                            slice.start.gen.py_ast[0]
+                                            if slice.start
+                                            else None
+                                        ),
+                                        upper=(
+                                            slice.stop.gen.py_ast[0]
+                                            if slice.stop
+                                            else None
+                                        ),
+                                        step=(
+                                            slice.step.gen.py_ast[0]
+                                            if slice.step
+                                            else None
+                                        ),
+                                    )
+                                )
+                                for slice in node.slices
+                            ],
+                            ctx=ast3.Load(),
+                        )
                     )
-                )
-            ]
+                ]
+            elif len(node.slices) == 1:  # Single slice. Example arr[a]
+                slice = node.slices[0]
+                node.gen.py_ast = [
+                    self.sync(
+                        ast3.Slice(
+                            lower=slice.start.gen.py_ast[0] if slice.start else None,
+                            upper=slice.stop.gen.py_ast[0] if slice.stop else None,
+                            step=slice.step.gen.py_ast[0] if slice.step else None,
+                        )
+                    )
+                ]
         else:
-            node.gen.py_ast = node.start.gen.py_ast if node.start else []
+            if len(node.slices) > 0 and node.slices[0].start is not None:
+                node.gen.py_ast = node.slices[0].start.gen.py_ast
+            else:
+                node.gen.py_ast = []
 
     def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None:
         """Sub objects.

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -2026,9 +2026,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             and (isinstance(step, ast.Expr) or step is None)
         ):
             return ast.IndexSlice(
-                start=lower,
-                stop=upper,
-                step=step,
+                slices=[ast.IndexSlice.Slice(lower, upper, step)],
                 is_range=True,
                 kid=valid_kid,
             )
@@ -2061,12 +2059,28 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         slice = self.convert(node.slice)
         if not isinstance(slice, ast.IndexSlice) and isinstance(slice, ast.Expr):
             slice = ast.IndexSlice(
-                start=slice,
-                stop=None,
-                step=None,
+                slices=[ast.IndexSlice.Slice(slice, None, None)],
                 is_range=False,
                 kid=[slice],
             )
+        if (
+            not isinstance(slice, ast.IndexSlice)
+            and isinstance(slice, ast.TupleVal)
+            and slice.values is not None
+        ):
+
+            slices: list[ast.IndexSlice.Slice] = []
+            for index_slice in slice.values.items:
+                if not isinstance(index_slice, ast.IndexSlice):
+                    raise self.ice()
+                slices.append(index_slice.slices[0])
+
+            slice = ast.IndexSlice(
+                slices=slices,
+                is_range=True,
+                kid=[slice],
+            )
+
         if isinstance(value, ast.Expr) and isinstance(slice, ast.IndexSlice):
             return ast.AtomTrailer(
                 target=value,

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -995,8 +995,7 @@ class SymTabBuildPass(Pass):
     def enter_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: Optional[ExprType],
-        stop: Optional[ExprType],
+        slices: list[Slice],
         is_range: bool,
         """
         self.sync_node_to_scope(node)

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

@@ -0,0 +1,26 @@
+
+# 1. Test initialization order.
+obj Test1 {
+    has var1: int;
+    has var2: int = 42;
+    has var3: int; # <-- This should be syntax error.
+}
+
+
+# 2. Test if postinit is needed but not provided.
+obj Test2 {
+    has var1: str;
+    has var2: int by postinit;
+}
+
+# 3. Postinit should be considered as has default initialization.
+obj Test3 {
+    has var1: int;
+    has var2: int = 42;
+    has var3: int by postinit;  # <-- This is fine.
+    has var4: int;  # <-- This should be syntax error.
+
+    can postinit() {
+        self.var3 = 3;
+    }
+}

jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py

@@ -43,35 +43,6 @@ class DeclImplMatchPassTests(TestCase):
         for exp in expected_stdout_values:
             self.assertIn(exp, errors_output)
 
-    def test_parameter_name_mismatch(self) -> None:
-        """Basic test for pass."""
-        state = jac_file_to_pass(
-            self.fixture_abs_path("defn_decl_mismatch.jac"), DeclImplMatchPass
-        )
-
-        expected_stdout_values = (
-            "Parameter name mismatch for ability (o)SomeObj.(c)bar.",
-            "   14 |",
-            "   15 | # Mis matching parameter name.",
-            "   16 | :obj:SomeObj:can:bar(param1: str, praam2:int) -> str {",
-            "      |                                   ^^^^^^",
-            '   17 |     return "bar";',
-            "   18 | }",
-            "From the declaration of bar.",
-            "    3 | obj SomeObj {",
-            "    4 |     can foo(param1: str, param2:int) -> str;",
-            "    5 |     can bar(param1: str, param2:int) -> str;",
-            "      |                          ^^^^^^",
-            "    6 | }",
-        )
-
-        errors_output = ""
-        for error in state.errors_had:
-            errors_output += error.pretty_print() + "\n"
-
-        for exp in expected_stdout_values:
-            self.assertIn(exp, errors_output)
-
     def test_ability_connected_to_decl(self) -> None:
         """Basic test for pass."""
         state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclImplMatchPass)
@@ -105,3 +76,39 @@ class DeclImplMatchPassTests(TestCase):
         )
         for i in state.ir.get_all_sub_nodes(ast.ArchRef):
             self.assertIsNotNone(i.sym)
+
+    def test_obj_hasvar_initialization(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("uninitialized_hasvars.jac"), DeclImplMatchPass
+        )
+        self.assertTrue(state.errors_had)
+
+        expected_stdout_values = (
+            "Non default attribute 'var3' follows default attribute",
+            "    4 |     has var1: int;",
+            "    5 |     has var2: int = 42;",
+            "    6 |     has var3: int; # <-- This should be syntax error.",
+            "      |         ^^^^",
+            "    7 | }",
+            'Missing "postinit" method required by un initialized attribute(s).',
+            "   11 | obj Test2 {",
+            "   12 |     has var1: str;",
+            "   13 |     has var2: int by postinit;",
+            "      |         ^^^^",
+            "   14 | }",
+            "Non default attribute 'var4' follows default attribute",
+            "   19 |     has var2: int = 42;",
+            "   20 |     has var3: int by postinit;  # <-- This is fine.",
+            "   21 |     has var4: int;  # <-- This should be syntax error.",
+            "      |         ^^^^",
+            "   22 |",
+            "   23 |     can postinit() {",
+        )
+
+        errors_output = ""
+        for error in state.errors_had:
+            errors_output += error.pretty_print() + "\n"
+
+        for exp in expected_stdout_values:
+            self.assertIn(exp, errors_output)

jaclang/compiler/passes/main/tests/test_def_use_pass.py

@@ -19,7 +19,7 @@ class DefUsePassTests(TestCase):
             target=DefUsePass,
         )
         uses = [i.uses for i in state.ir.sym_tab.kid[0].tab.values()]
+        self.assertEqual(len(uses[0]), 1)
         self.assertEqual(len(uses[1]), 1)
-        self.assertEqual(len(uses[2]), 1)
-        self.assertIn("output", [uses[1][0].sym_name, uses[2][0].sym_name])
-        self.assertIn("message", [uses[1][0].sym_name, uses[2][0].sym_name])
+        self.assertIn("output", [uses[0][0].sym_name, uses[1][0].sym_name])
+        self.assertIn("message", [uses[0][0].sym_name, uses[1][0].sym_name])

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -1640,8 +1640,8 @@ class JacFormatPass(Pass):
     def exit_index_slice(self, node: ast.IndexSlice) -> None:
         """Sub objects.
 
-        start: ExprType,
-        stop: Optional[ExprType],
+        slices: list[Slice],
+        is_range: bool,
         """
         for i in node.kid:
             self.emit(node, i.gen.jac)

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

@@ -34,6 +34,8 @@ glob exec_ctx = ExecutionContext();
 
 obj Anchor :ArchitypeProtocol: {
     has ob: object,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc],
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
         persist: bool = False,
@@ -41,9 +43,7 @@ obj Anchor :ArchitypeProtocol: {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory,
-        ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
+        mem: Memory = exec_ctx.memory;
 
     static can on_entry(cls: type, triggers: list[type]);
     static can on_exit(cls: type, triggers: list[type]);

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

@@ -33,6 +33,8 @@ glob exec_ctx = ExecutionContext();
 
 obj Anchor :ArchitypeProtocol: {
     has ob: object,
+        ds_entry_funcs: list[DSFunc],
+        ds_exit_funcs: list[DSFunc],
         jid: UUID = :> uuid4,
         timestamp: datetime = :> datetime.now,
         persist: bool = False,
@@ -40,9 +42,7 @@ obj Anchor :ArchitypeProtocol: {
         rw_access: set = :> set,
         ro_access: set = :> set,
         owner_id: UUID = exec_ctx.master,
-        mem: Memory = exec_ctx.memory,
-        ds_entry_funcs: list[DSFunc],
-        ds_exit_funcs: list[DSFunc];
+        mem: Memory = exec_ctx.memory;
 
     static can on_entry(cls: type, triggers: list[type]);
     static can on_exit(cls: type, triggers: list[type]);

jaclang/compiler/tests/test_parser.py

@@ -1,6 +1,7 @@
 """Tests for Jac parser."""
 
 import inspect
+import os
 
 from jaclang.compiler import jac_lark as jl
 from jaclang.compiler.absyntree import JacSource
@@ -27,7 +28,12 @@ class TestLarkParser(TestCaseMicroSuite):
         prse = JacParser(
             input_ir=JacSource(self.file_to_str(filename), mod_path=filename),
         )
-        self.assertFalse(prse.errors_had)
+        # A list of files where the errors are expected.
+        files_expected_errors = [
+            "uninitialized_hasvars.jac",
+        ]
+        if os.path.basename(filename) not in files_expected_errors:
+            self.assertFalse(prse.errors_had)
 
     def test_parser_fam(self) -> None:
         """Parse micro jac file."""