jaclang 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

jaclang/compiler/parser.py

@@ -546,6 +546,22 @@ class JacParser(Transform[uni.Source, uni.Module]):
             )
             return impl
 
+        def sem_def(self, _: None) -> uni.SemDef:
+            """Grammar rule.
+
+            sem_def: KW_SEM dotted_name EQ multistring SEMI
+            """
+            self.consume_token(Tok.KW_SEM)
+            target = self.extract_from_list(self.consume(list), uni.NameAtom)
+            self.consume_token(Tok.EQ)
+            value = self.consume(uni.String)
+            self.consume_token(Tok.SEMI)
+            return uni.SemDef(
+                target=target,
+                value=value,
+                kid=self.flat_cur_nodes,
+            )
+
         def impl_spec(
             self, _: None
         ) -> Sequence[uni.Expr] | uni.FuncSignature | uni.EventSignature:
@@ -1749,10 +1765,10 @@ class JacParser(Transform[uni.Source, uni.Module]):
             """
             return self._binary_expr_unwind(self.cur_nodes)
 
-        def ds_spawn(self, _: None) -> uni.Expr:
+        def os_spawn(self, _: None) -> uni.Expr:
             """Grammar rule.
 
-            ds_spawn: (ds_spawn KW_SPAWN)? unpack
+            os_spawn: (os_spawn KW_SPAWN)? unpack
             """
             return self._binary_expr_unwind(self.cur_nodes)
 
@@ -1862,15 +1878,16 @@ class JacParser(Transform[uni.Source, uni.Module]):
         def atomic_call(self, _: None) -> uni.FuncCall:
             """Grammar rule.
 
-            atomic_call: atomic_chain LPAREN param_list? (KW_BY atomic_call)? RPAREN
+            atomic_call: atomic_chain LPAREN param_list? by_call? RPAREN by_call?
             """
             genai_call: uni.FuncCall | None = None
             target = self.consume(uni.Expr)
             self.consume_token(Tok.LPAREN)
             params_sn = self.match(list)
-            if self.match_token(Tok.KW_BY):
-                genai_call = self.consume(uni.FuncCall)
+            genai_call = self.match(uni.FuncCall)
             self.consume_token(Tok.RPAREN)
+            body_genai_call = self.match(uni.FuncCall)
+
             return uni.FuncCall(
                 target=target,
                 params=(
@@ -1879,9 +1896,20 @@ class JacParser(Transform[uni.Source, uni.Module]):
                     else []
                 ),
                 genai_call=genai_call,
+                body_genai_call=body_genai_call,
                 kid=self.flat_cur_nodes,
             )
 
+        def by_call(self, _: None) -> uni.FuncCall:
+            """Grammar rule.
+
+            by_call: KW_BY expression
+            """
+            self.consume_token(Tok.KW_BY)
+            if call := self.match(uni.FuncCall):
+                return call
+            raise ValueError("Expected a function call")
+
         def index_slice(self, _: None) -> uni.IndexSlice:
             """Grammar rule.
 
@@ -2896,18 +2924,14 @@ class JacParser(Transform[uni.Source, uni.Module]):
         def event_clause(self, _: None) -> uni.EventSignature:
             """Grammar rule.
 
-            event_clause: KW_WITH expression? (KW_EXIT | KW_ENTRY) (RETURN_HINT expression)?
+            event_clause: KW_WITH expression? (KW_EXIT | KW_ENTRY)
             """
-            return_spec: uni.Expr | None = None
             self.consume_token(Tok.KW_WITH)
             type_specs = self.match(uni.Expr)
             event = self.match_token(Tok.KW_EXIT) or self.consume_token(Tok.KW_ENTRY)
-            if self.match_token(Tok.RETURN_HINT):
-                return_spec = self.consume(uni.Expr)
             return uni.EventSignature(
                 event=event,
                 arch_tag_info=type_specs,
-                return_type=return_spec,
                 kid=self.cur_nodes,
             )
 

jaclang/compiler/passes/main/__init__.py

@@ -1,12 +1,11 @@
 """Collection of passes for Jac IR."""
 
-from enum import Enum
-
 from ..transform import Alert, Transform  # noqa: I100
 from .annex_pass import JacAnnexPass  # noqa: I100
 from .sym_tab_build_pass import SymTabBuildPass, UniPass  # noqa: I100
 from .sym_tab_link_pass import SymTabLinkPass  # noqa: I100
 from .def_use_pass import DefUsePass  # noqa: I100
+from .sem_def_match_pass import SemDefMatchPass  # noqa: I100
 from .import_pass import JacImportDepsPass, PyImportDepsPass  # noqa: I100
 from .def_impl_match_pass import DeclImplMatchPass  # noqa: I100
 from .pyast_load_pass import PyastBuildPass  # type: ignore # noqa: I100
@@ -17,17 +16,6 @@ from .pyjac_ast_link_pass import PyJacAstLinkPass  # noqa: I100
 from .inheritance_pass import InheritancePass  # noqa: I100
 
 
-class CompilerMode(Enum):
-    """Compiler modes."""
-
-    PARSE = "PARSE"
-    NO_CGEN = "NO_CGEN"
-    NO_CGEN_SINGLE = "NO_CGEN_SINGLE"
-    COMPILE = "COMPILE"
-    COMPILE_SINGLE = "COMPILE_SINGLE"
-    TYPECHECK = "TYPECHECK"
-
-
 __all__ = [
     "Alert",
     "Transform",
@@ -39,10 +27,10 @@ __all__ = [
     "SymTabLinkPass",
     "DeclImplMatchPass",
     "DefUsePass",
+    "SemDefMatchPass",
     "PyastBuildPass",
     "PyastGenPass",
     "PyBytecodeGenPass",
-    "CompilerMode",
     "CFGBuildPass",
     "PyJacAstLinkPass",
     "InheritancePass",

jaclang/compiler/passes/main/annex_pass.py

@@ -48,8 +48,6 @@ class JacAnnexPass(Transform[uni.Module, uni.Module]):
 
     def load_annexes(self, jac_program: JacProgram, node: uni.Module) -> None:
         """Parse and attach annex modules to the node."""
-        from jaclang.compiler.program import CompilerMode
-
         if node.stub_only or not self.mod_path.endswith(".jac"):
             return
         if not self.mod_path:
@@ -64,9 +62,7 @@ class JacAnnexPass(Transform[uni.Module, uni.Module]):
                 path.startswith(f"{self.base_path}.")
                 or os.path.dirname(path) == self.impl_folder
             ):
-                mod = jac_program.compile(
-                    file_path=path, mode=CompilerMode.NO_CGEN_SINGLE
-                )
+                mod = jac_program.compile(file_path=path, no_cgen=True)
                 if mod:
                     node.impl_mod.append(mod)
 
@@ -78,8 +74,6 @@ class JacAnnexPass(Transform[uni.Module, uni.Module]):
                     or os.path.dirname(path) == self.test_folder
                 )
             ):
-                mod = jac_program.compile(
-                    file_path=path, mode=CompilerMode.NO_CGEN_SINGLE
-                )
+                mod = jac_program.compile(file_path=path, no_cgen=True)
                 if mod:
                     node.test_mod.append(mod)

jaclang/compiler/passes/main/cfg_build_pass.py

@@ -10,6 +10,8 @@ The CFG provides a foundation for data flow analysis, optimization, and understa
 The pass also includes functionality to coalesce basic blocks and generate visual representations of the CFG.
 """
 
+from typing import Sequence
+
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes import UniPass
 
@@ -65,26 +67,48 @@ class CFGBuildPass(UniPass):
             else:
                 target.bb_in = [source]
 
+    def get_code_block_sequence(
+        self, node: uni.CodeBlockStmt
+    ) -> list[uni.UniCFGNode] | None:
+        """Get code block sequence."""
+        sequence: list[uni.UniCFGNode] = []
+        if hasattr(node, "body") and isinstance(node.body, Sequence):
+            for bbs in node.body:
+                if isinstance(bbs, uni.UniCFGNode):
+                    sequence.append(bbs)
+            if sequence:
+                return sequence
+            else:
+                return None
+        else:
+            return None
+
     def enter_node(self, node: uni.UniNode) -> None:
         """Enter BasicBlockStmt nodes."""
         if isinstance(node, uni.UniCFGNode) and not isinstance(node, uni.Semi):
-            if node.parent and isinstance(node, uni.CodeBlockStmt) and self.first_exit:
-                bb_stmts = [
-                    bbs for bbs in node.parent.kid if isinstance(bbs, uni.UniCFGNode)
-                ]
+            # check if the current node is a CodeBlockStmt in a sequence of statements
+            bb_stmts = self.get_code_block_sequence(node.parent)
+            if (
+                isinstance(node, uni.CodeBlockStmt)
+                and node.parent
+                and (not (isinstance(node, (uni.ElseIf, uni.ElseStmt))))
+                and bb_stmts
+                and self.first_exit
+            ):
+                # bb_stmts = self.get_code_block_sequence(node.parent)
+                # bb_stmts = [
+                #     bbs for bbs in node.parent.body if isinstance(bbs, uni.UniCFGNode)
+                # ]
                 if (
-                    node.parent.parent
-                    and isinstance(node.parent.parent, uni.Archetype)
+                    node.parent
+                    and isinstance(node.parent, uni.Archetype)
                     # and isinstance(node.parent.parent, uni.BasicBlockStmt)
                 ):
-                    parent_obj = node.parent.parent
+                    parent_obj = node.parent
                     if parent_obj:
                         self.link_bbs(parent_obj, node)
                 elif bb_stmts[0] == node:
-                    if (
-                        isinstance(node.parent.parent, uni.ModuleCode)
-                        and self.to_connect
-                    ):
+                    if isinstance(node.parent, uni.ModuleCode) and self.to_connect:
                         for bb in self.to_connect:
                             self.link_bbs(bb, node)
                             self.to_connect.remove(bb)  # if self.to_connect:
@@ -92,7 +116,9 @@ class CFGBuildPass(UniPass):
                         parent_bb = self.get_parent_bb_stmt(node)
                         if parent_bb:
                             self.link_bbs(parent_bb, node)
-                elif self.to_connect:
+                elif self.to_connect and not isinstance(
+                    node, (uni.ElseIf, uni.ElseStmt)
+                ):
                     to_remove = []
                     for parent in self.to_connect:
                         if isinstance(parent, uni.UniCFGNode):

jaclang/compiler/passes/main/import_pass.py

@@ -63,8 +63,6 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
 
     def import_jac_module(self, node: uni.ModulePath) -> None:
         """Import a module."""
-        from jaclang.compiler.passes.main import CompilerMode as CMode
-
         target = node.resolve_relative_path()
         # If the module is a package (dir)
         if os.path.isdir(target):
@@ -83,15 +81,11 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
                         else:
                             if from_mod_target in self.prog.mod.hub:
                                 return
-                            self.load_mod(
-                                self.prog.compile(
-                                    file_path=from_mod_target, mode=CMode.PARSE
-                                )
-                            )
+                            self.load_mod(self.prog.compile(file_path=from_mod_target))
         else:
             if target in self.prog.mod.hub:
                 return
-            self.load_mod(self.prog.compile(file_path=target, mode=CMode.PARSE))
+            self.load_mod(self.prog.compile(file_path=target))
 
     def load_mod(self, mod: uni.Module) -> None:
         """Attach a module to a node."""
@@ -102,13 +96,11 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
 
     def import_jac_mod_from_dir(self, target: str) -> uni.Module:
         """Import a module from a directory."""
-        from jaclang.compiler.passes.main import CompilerMode as CMode
-
         jac_init_path = os.path.join(target, "__init__.jac")
         if os.path.exists(jac_init_path):
             if jac_init_path in self.prog.mod.hub:
                 return self.prog.mod.hub[jac_init_path]
-            return self.prog.compile(file_path=jac_init_path, mode=CMode.PARSE)
+            return self.prog.compile(file_path=jac_init_path)
         elif os.path.exists(py_init_path := os.path.join(target, "__init__.py")):
             with open(py_init_path, "r") as f:
                 file_source = f.read()