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

jaclang/compiler/parser.py

@@ -43,14 +43,22 @@ class JacParser(Pass):
                 raise self.ice()
         except jl.UnexpectedInput as e:
             catch_error = ast.EmptyToken()
-            catch_error.file_path = self.mod_path
+            catch_error.orig_src = self.source
             catch_error.line_no = e.line
             catch_error.end_line = e.line
             catch_error.c_start = e.column
             catch_error.c_end = e.column + 1
-            self.error(f"Syntax Error: {e}", node_override=catch_error)
+            catch_error.pos_start = e.pos_in_stream or 0
+            catch_error.pos_end = catch_error.pos_start + 1
+
+            error_msg = "Syntax Error"
+            if len(e.args) >= 1 and isinstance(e.args[0], str):
+                error_msg += e.args[0]
+            self.error(error_msg, node_override=catch_error)
+
         except Exception as e:
             self.error(f"Internal Error: {e}")
+
         return ast.Module(
             name="",
             source=self.source,
@@ -65,7 +73,7 @@ class JacParser(Pass):
     def proc_comment(token: jl.Token, mod: ast.AstNode) -> ast.CommentToken:
         """Process comment."""
         return ast.CommentToken(
-            file_path=mod.loc.mod_path,
+            orig_src=mod.loc.orig_src,
             name=token.type,
             value=token.value,
             line=token.line if token.line is not None else 0,
@@ -166,7 +174,7 @@ class JacParser(Pass):
                 kid=(
                     kid
                     if len(kid)
-                    else [ast.EmptyToken(file_path=self.parse_ref.mod_path)]
+                    else [ast.EmptyToken(ast.JacSource("", self.parse_ref.mod_path))]
                 ),
             )
             return self.nu(mod)
@@ -706,10 +714,12 @@ class JacParser(Pass):
                     | NAME (COLON STRING)?
                     | py_code_block
                     | free_code
+                    | abstract_ability
+                    | ability
             """
-            if isinstance(kid[0], ast.PyInlineCode):
+            if isinstance(kid[0], (ast.PyInlineCode, ast.Ability)):
                 return self.nu(kid[0])
-            if isinstance(kid[0], (ast.Name)):
+            elif isinstance(kid[0], (ast.Name)):
                 if (
                     len(kid) >= 3
                     and isinstance(kid[-1], ast.Expr)
@@ -1010,7 +1020,11 @@ class JacParser(Pass):
                         kid=(
                             kid
                             if len(kid)
-                            else [ast.EmptyToken(file_path=self.parse_ref.mod_path)]
+                            else [
+                                ast.EmptyToken(
+                                    ast.JacSource("", self.parse_ref.mod_path)
+                                )
+                            ]
                         ),
                     )
                 )
@@ -1228,7 +1242,7 @@ class JacParser(Pass):
                 return self.nu(
                     ast.BuiltinType(
                         name=kid[0].name,
-                        file_path=self.parse_ref.mod_path,
+                        orig_src=self.parse_ref.source,
                         value=kid[0].value,
                         line=kid[0].loc.first_line,
                         end_line=kid[0].loc.last_line,
@@ -2422,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]
@@ -2440,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,
                         )
@@ -2450,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,
                     )
@@ -2786,25 +2817,14 @@ class JacParser(Pass):
         def name_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Name]:
             """Grammar rule.
 
-            name_list: (name_list COMMA)? NAME
+            name_list: (named_ref COMMA)* named_ref
             """
-            consume = None
-            name = None
-            comma = None
-            if isinstance(kid[0], ast.SubNodeList):
-                consume = kid[0]
-                comma = kid[1]
-                name = kid[2]
-                new_kid = [*consume.kid, comma, name]
-            else:
-                name = kid[0]
-                new_kid = [name]
-            valid_kid = [i for i in new_kid if isinstance(i, ast.Name)]
+            valid_kid = [i for i in kid if isinstance(i, ast.Name)]
             return self.nu(
                 ast.SubNodeList[ast.Name](
                     items=valid_kid,
                     delim=Tok.COMMA,
-                    kid=new_kid,
+                    kid=kid,
                 )
             )
 
@@ -3996,7 +4016,7 @@ class JacParser(Pass):
             elif token.type == Tok.PYNLINE and isinstance(token.value, str):
                 token.value = token.value.replace("::py::", "")
             ret = ret_type(
-                file_path=self.parse_ref.mod_path,
+                orig_src=self.parse_ref.source,
                 name=token.type,
                 value=token.value[2:] if token.type == Tok.KWESC_NAME else token.value,
                 line=token.line if token.line is not None else 0,

jaclang/compiler/passes/ir_pass.py

@@ -140,11 +140,11 @@ class Pass(Transform[T]):
 
     def error(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.log_error(f"{msg}", node_override=node_override)
+        self.log_error(msg, node_override=node_override)
 
     def warning(self, msg: str, node_override: Optional[ast.AstNode] = None) -> None:
         """Pass Error."""
-        self.log_warning(f"{msg}", node_override=node_override)
+        self.log_warning(msg, node_override=node_override)
 
     def ice(self, msg: str = "Something went horribly wrong!") -> RuntimeError:
         """Pass Error."""

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
@@ -90,6 +91,10 @@ class DeclImplMatchPass(Pass):
                     raise self.ice(
                         f"Expected AstImplNeedingNode, got {valid_decl.__class__.__name__}. Not possible."
                     )
+
+                # Ensure if it's an ability def impl, the parameters are matched.
+                self.validate_params_match(sym, decl_node.name_of)
+
                 valid_decl.body = sym.decl.name_of
                 sym.decl.name_of.decl_link = valid_decl
                 for idx, a in enumerate(sym.decl.name_of.target.archs):
@@ -97,5 +102,83 @@ class DeclImplMatchPass(Pass):
                     a.name_spec.sym = name_of_links[idx].sym
                 sym.decl.name_of.sym_tab.tab.update(valid_decl.sym_tab.tab)
                 valid_decl.sym_tab.tab = sym.decl.name_of.sym_tab.tab
+
         for i in sym_tab.kid:
             self.connect_def_impl(i)
+
+    def validate_params_match(self, sym: Symbol, valid_decl: ast.AstSymbolNode) -> None:
+        """Validate if the parameters match."""
+        if (
+            isinstance(valid_decl, ast.Ability)
+            and isinstance(sym.decl.name_of, ast.AbilityDef)
+            and isinstance(valid_decl.signature, ast.FuncSignature)
+            and isinstance(sym.decl.name_of.signature, ast.FuncSignature)
+        ):
+
+            params_decl = valid_decl.signature.params
+            params_defn = sym.decl.name_of.signature.params
+
+            if params_decl and params_defn:
+                # Check if the parameter count is matched.
+                if len(params_defn.items) != len(params_decl.items):
+                    self.error(
+                        f"Parameter count mismatch for ability {sym.sym_name}.",
+                        sym.decl.name_of.name_spec,
+                    )
+                    self.error(
+                        f"From the declaration of {valid_decl.name_spec.sym_name}.",
+                        valid_decl.name_spec,
+                    )
+                else:
+                    # Copy the parameter names from the declaration to the definition.
+                    for idx in range(len(params_defn.items)):
+                        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"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,
         """