jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -1,131 +1,170 @@
-"""Connect Decls and Defs in AST.
-
-This pass creates links in the ast between Decls of Architypes and Abilities
-that are separate from their implementations (Defs). This pass creates a link
-in the ast between the Decls and Defs of Architypes and Abilities through the
-body field.
+"""Declaration-Implementation Matching Pass for the Jac compiler.
+
+This pass connects declarations (Decls) of Archetypes and Abilities with their separate
+implementations (Defs) in the AST. It:
+
+1. Establishes links between declarations in the main module and their implementations
+   in separate .impl.jac files
+2. Validates parameter matching between ability declarations and their implementations
+3. Ensures proper inheritance of symbol tables between declarations and implementations
+4. Performs validation checks on archetypes, including:
+   - Proper ordering of default and non-default attributes
+   - Presence of required postinit methods for deferred attributes
+   - Abstract ability implementation validation
+
+This pass is essential for Jac's separation of interface and implementation, allowing
+developers to define archetype and ability interfaces in one file while implementing
+their behavior in separate files.
 """
 
-import jaclang.compiler.absyntree as ast
+import jaclang.compiler.unitree as uni
 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
+from jaclang.compiler.passes.transform import Transform
+from jaclang.compiler.unitree import Symbol, UniScopeNode
 
 
-class DeclImplMatchPass(Pass):
+class DeclImplMatchPass(Transform[uni.Module, uni.Module]):
     """Decls and Def matching pass."""
 
-    def enter_module(self, node: ast.Module) -> None:
-        """Enter module."""
-        if not node.sym_tab:
-            self.error(
-                f"Expected symbol table on node {node.__class__.__name__}. Perhaps an earlier pass failed."
-            )
-        else:
-            self.connect_def_impl(node.sym_tab)
+    def transform(self, ir_in: uni.Module) -> uni.Module:
+        """Connect Decls and Defs."""
+        self.cur_node = ir_in
 
-    def after_pass(self) -> None:
-        """Rebuild sub node table."""
-        self.ir = SubNodeTabPass(input_ir=self.ir, prior=self).ir
+        self.connect_impls(ir_in.sym_tab, ir_in.sym_tab)
+        for impl_module in ir_in.impl_mod:
+            self.connect_impls(impl_module.sym_tab, ir_in.sym_tab)
 
-    def defn_lookup(self, lookup: Symbol) -> ast.NameAtom | None:
+        self.check_archetypes(ir_in)
+        return ir_in
+
+    def defn_lookup(self, lookup: Symbol) -> uni.NameAtom | None:
         """Lookup a definition in a symbol table."""
         for defn in range(len(lookup.defn)):
             candidate = lookup.defn[len(lookup.defn) - (defn + 1)]
             if (
-                isinstance(candidate.name_of, ast.AstImplNeedingNode)
+                isinstance(candidate.name_of, uni.AstImplNeedingNode)
                 and candidate.name_of.needs_impl
             ):
                 return candidate
         return None
 
-    def connect_def_impl(self, sym_tab: SymbolTable) -> None:
-        """Connect Decls and Defs."""
-        for sym in sym_tab.tab.values():
-            if isinstance(sym.decl.name_of, ast.AstImplOnlyNode):
-                # currently strips the type info from impls
-                arch_refs = [x[3:] for x in sym.sym_name.split(".")]
-                name_of_links: list[ast.NameAtom] = []  # to link archref names to decls
-                lookup = sym_tab.lookup(arch_refs[0])
-                # If below may need to be a while instead of if to skip over local
-                # import name collisions (see test: test_impl_decl_resolution_fix)
-                if lookup and not isinstance(
-                    lookup.decl.name_of, ast.AstImplNeedingNode
-                ):
-                    lookup = (
-                        sym_tab.parent.lookup(arch_refs[0]) if sym_tab.parent else None
-                    )
-                decl_node = (
-                    self.defn_lookup(lookup)
-                    if len(arch_refs) == 1 and lookup
-                    else lookup.defn[-1] if lookup else None
+    def connect_impls(
+        self, source_sym_tab: UniScopeNode, target_sym_tab: UniScopeNode
+    ) -> None:
+        """Connect implementations from source symbol table to declarations in target symbol table.
+
+        When source_sym_tab and target_sym_tab are the same, this connects within the same module.
+        When different, it connects implementations from impl_mod to declarations in the main module.
+        """
+        # Process all symbols in the source symbol table
+        for sym in source_sym_tab.names_in_scope.values():
+            if not isinstance(sym.decl.name_of, uni.ImplDef):
+                continue
+
+            # Extract archetype references
+            arch_refs = sym.sym_name.split(".")[1:]  # Remove the impl. prefix
+            name_of_links: list[uni.NameAtom] = []  # to link archref names to decls
+
+            # Look up the archetype in the target symbol table
+            lookup = target_sym_tab.lookup(arch_refs[0])
+
+            # Skip over local import name collisions
+            if lookup and not isinstance(lookup.decl.name_of, uni.AstImplNeedingNode):
+                lookup = (
+                    target_sym_tab.parent_scope.lookup(arch_refs[0])
+                    if target_sym_tab.parent_scope
+                    else target_sym_tab.lookup(arch_refs[0])
                 )
-                name_of_links.append(decl_node) if decl_node else None
-                for name in arch_refs[1:]:
-                    if decl_node:
-                        lookup = (
-                            decl_node.name_of.sym_tab.lookup(name, deep=False)
-                            if decl_node.name_of.sym_tab
-                            else None
-                        )
-                        decl_node = (
-                            self.defn_lookup(lookup)
-                            if len(arch_refs) == 1 and lookup
-                            else lookup.defn[-1] if lookup else None
-                        )
-                        name_of_links.append(decl_node) if decl_node else None
-                    else:
-                        break
-                if not decl_node:
-                    continue
-                elif isinstance(decl_node, ast.Ability) and decl_node.is_abstract:
-                    self.warning(
-                        f"Abstract ability {decl_node.py_resolve_name()} should not have a definition.",
-                        decl_node,
+
+            decl_node = (
+                self.defn_lookup(lookup)
+                if len(arch_refs) == 1 and lookup
+                else lookup.defn[-1] if lookup else None
+            )
+            name_of_links.append(decl_node) if decl_node else None
+
+            for name in arch_refs[1:]:
+                if decl_node:
+                    lookup = (
+                        decl_node.name_of.sym_tab.lookup(name, deep=False)
+                        if decl_node.name_of.sym_tab
+                        else None
                     )
-                    continue
-                if not isinstance(
-                    valid_decl := decl_node.name_of, ast.AstImplNeedingNode
-                ) or not (valid_decl.sym_tab and sym.decl.name_of.sym_tab):
-                    raise self.ice(
-                        f"Expected AstImplNeedingNode, got {valid_decl.__class__.__name__}. Not possible."
+                    decl_node = (
+                        self.defn_lookup(lookup)
+                        if len(arch_refs) == 1 and lookup
+                        else lookup.defn[-1] if lookup else None
                     )
+                    name_of_links.append(decl_node) if decl_node else None
+                else:
+                    break
+
+            if not decl_node:
+                # self.log_error(
+                #     f"Implementation for '{sym.sym_name}' cannot be matched to any declaration.",
+                #     sym.decl.name_of,
+                # )
+                continue
+            elif isinstance(decl_node, uni.Ability) and decl_node.is_abstract:
+                self.log_warning(
+                    f"Abstract ability {decl_node.py_resolve_name()} should not have a definition.",
+                    decl_node,
+                )
+                continue
+
+            if not isinstance(
+                valid_decl := decl_node.name_of, uni.AstImplNeedingNode
+            ) or not (valid_decl.sym_tab and sym.decl.name_of.sym_tab):
+                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)
+            # 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):
+            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.items):
+                if idx < len(name_of_links) and name_of_links[idx]:
                     a.name_spec.name_of = name_of_links[idx].name_of
                     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)
+            sym.decl.name_of.sym_tab.names_in_scope.update(
+                valid_decl.sym_tab.names_in_scope
+            )
+            valid_decl.sym_tab.names_in_scope = sym.decl.name_of.sym_tab.names_in_scope
+
+        # Process kid scopes recursively
+        for source_scope in source_sym_tab.kid_scope:
+            # If source and target are the same, process within the same scope
+            if source_sym_tab is target_sym_tab:
+                self.connect_impls(source_scope, source_scope)
+            else:
+                # Otherwise, try to find corresponding scopes by name
+                for target_scope in target_sym_tab.kid_scope:
+                    if source_scope.scope_name == target_scope.scope_name:
+                        self.connect_impls(source_scope, target_scope)
+                        break
 
-    def validate_params_match(self, sym: Symbol, valid_decl: ast.AstSymbolNode) -> None:
+    def validate_params_match(self, sym: Symbol, valid_decl: uni.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)
+            isinstance(valid_decl, uni.Ability)
+            and isinstance(sym.decl.name_of, uni.ImplDef)
+            and isinstance(valid_decl.signature, uni.FuncSignature)
+            and isinstance(sym.decl.name_of.spec, uni.FuncSignature)
         ):
 
             params_decl = valid_decl.signature.params
-            params_defn = sym.decl.name_of.signature.params
+            params_defn = sym.decl.name_of.spec.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(
+                    self.log_error(
                         f"Parameter count mismatch for ability {sym.sym_name}.",
                         sym.decl.name_of.name_spec,
                     )
-                    self.error(
+                    self.log_error(
                         f"From the declaration of {valid_decl.name_spec.sym_name}.",
                         valid_decl.name_spec,
                     )
@@ -136,49 +175,54 @@ class DeclImplMatchPass(Pass):
                     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."""
+    def check_archetypes(self, ir_in: uni.Module) -> None:
+        """Check all archetypes for issues with attributes and methods."""
+        for node in ir_in.get_all_sub_nodes(uni.Archetype):
+            self.check_archetype(node)
+
+    def check_archetype(self, node: uni.Archetype) -> None:
+        """Check a single archetype for issues."""
         if node.arch_type.name == Tok.KW_OBJECT and isinstance(
-            node.body, ast.SubNodeList
+            node.body, uni.SubNodeList
         ):
-
+            self.cur_node = node
             found_default_init = False
             for stmnt in node.body.items:
-                if not isinstance(stmnt, ast.ArchHas):
+                if not isinstance(stmnt, uni.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(
+                            self.log_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
+            post_init_vars: list[uni.HasVar] = []
+            postinit_method: uni.Ability | None = None
 
             for item in node.body.items:
 
-                if isinstance(item, ast.ArchHas):
+                if isinstance(item, uni.ArchHas):
                     for var in item.vars.items:
                         if var.defer:
                             post_init_vars.append(var)
 
-                elif isinstance(item, ast.Ability):
+                elif isinstance(item, uni.Ability):
                     if item.is_abstract:
                         continue
                     if (
-                        isinstance(item.name_ref, ast.SpecialVarRef)
+                        isinstance(item.name_ref, uni.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(
+                self.log_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.