jaclang 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

jaclang/compiler/passes/main/import_pass.py

@@ -17,14 +17,11 @@ The pass runs early in the compilation pipeline to ensure all symbols from impor
 modules are available for subsequent passes like symbol table building and type checking.
 """
 
-import ast as py_ast
 import os
-from typing import Optional
-
 
 import jaclang.compiler.unitree as uni
 from jaclang.compiler.passes import Transform, UniPass
-from jaclang.compiler.passes.main import SymTabBuildPass
+from jaclang.runtimelib.utils import read_file_with_encoding
 from jaclang.utils.log import logging
 
 
@@ -102,260 +99,15 @@ class JacImportDepsPass(Transform[uni.Module, uni.Module]):
                 return self.prog.mod.hub[jac_init_path]
             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()
-                mod = uni.Module.make_stub(
-                    inject_name=target.split(os.path.sep)[-1],
-                    inject_src=uni.Source(file_source, py_init_path),
-                )
-                self.prog.mod.hub[py_init_path] = mod
-                return mod
+            file_source = read_file_with_encoding(py_init_path)
+            mod = uni.Module.make_stub(
+                inject_name=target.split(os.path.sep)[-1],
+                inject_src=uni.Source(file_source, py_init_path),
+            )
+            self.prog.mod.hub[py_init_path] = mod
+            return mod
         else:
             return uni.Module.make_stub(
                 inject_name=target.split(os.path.sep)[-1],
                 inject_src=uni.Source("", target),
             )
-
-
-class PyImportDepsPass(JacImportDepsPass):
-    """Jac statically imports Python modules."""
-
-    def pre_transform(self) -> None:
-        """Initialize the PyImportPass."""
-        self.import_from_build_list: list[tuple[uni.Import, uni.Module]] = []
-
-    def transform(self, ir_in: uni.Module) -> uni.Module:
-        """Run Importer."""
-        self.__load_builtins()
-        self.import_from_build_list = []
-
-        # Add all modules from the program hub to last_imported to process their imports
-        self.last_imported = list(self.prog.mod.hub.values())
-
-        # Process imports until no more imported modules to process
-        while self.last_imported:
-            current_module = self.last_imported.pop(0)
-            all_imports = UniPass.get_all_sub_nodes(current_module, uni.ModulePath)
-            for i in all_imports:
-                self.process_import(i)
-
-        return ir_in
-
-    def process_import(self, i: uni.ModulePath) -> None:
-        """Process an import."""
-        # Process import is orginally implemented to handle ModulePath in Jaclang
-        # This won't work with py imports as this will fail to import stuff in form of
-        #      from a import b
-        #      from a import (c, d, e)
-        # Solution to that is to get the import node and check the from loc `then`
-        # handle it based on if there a from loc or not
-        imp_node = i.parent_of_type(uni.Import)
-
-        if imp_node.is_py:
-            if imp_node.from_loc:
-                msg = "Processing import from node at href="
-                msg += uni.Module.get_href_path(imp_node)
-                msg += f' path="{imp_node.loc.mod_path}, {imp_node.loc}"'
-                self.__process_import_from(imp_node)
-            else:
-                msg = "Processing import node at href="
-                msg += uni.Module.get_href_path(imp_node)
-                msg += f' path="{imp_node.loc.mod_path}, {imp_node.loc}"'
-                self.__process_import(imp_node)
-
-    def __process_import_from(self, imp_node: uni.Import) -> None:
-        """Process imports in the form of `from X import I`."""
-        assert isinstance(imp_node.from_loc, uni.ModulePath)
-
-        # Attempt to import the Python module X and process it
-        imported_mod = self.__import_py_module(
-            parent_node_path=uni.Module.get_href_path(imp_node),
-            mod_path=imp_node.from_loc.dot_path_str,
-        )
-
-        if imported_mod:
-            # Cyclic imports will happen in case of import sys
-            # sys stub file imports sys module which means that we need
-            # to import sys stub file again in the sys stub file and so on
-            # This can be detected by iterating over all the parents and make sure
-            # that the parent is in another file than the imported module
-            if self.__check_cyclic_imports(imp_node, imported_mod):
-                return
-
-            if imported_mod.name == "builtins":
-                return
-
-            msg = f"\tRegistering module:{imported_mod.name} to "
-            msg += f"import_from handling with {imp_node.loc.mod_path}:{imp_node.loc}"
-
-            self.load_mod(imported_mod)
-            self.import_from_build_list.append((imp_node, imported_mod))
-            SymTabBuildPass(ir_in=imported_mod, prog=self.prog)
-
-    def __process_import(self, imp_node: uni.Import) -> None:
-        """Process the imports in form of `import X`."""
-        # Expected that each ImportStatement will import one item
-        # In case of this assertion fired then we need to revisit this item
-        assert len(imp_node.items) == 1
-        imported_item = imp_node.items[0]
-        assert isinstance(imported_item, uni.ModulePath)
-
-        imported_mod = self.__import_py_module(
-            parent_node_path=uni.Module.get_href_path(imported_item),
-            mod_path=imported_item.dot_path_str,
-            imported_mod_name=(
-                # TODO: Check this replace
-                imported_item.dot_path_str.replace(".", "")
-                if not imported_item.alias
-                else imported_item.alias.sym_name
-            ),
-        )
-        if imported_mod:
-            if (
-                self.__check_cyclic_imports(imp_node, imported_mod)
-                or imported_mod.name == "builtins"
-            ):
-                return
-            self.load_mod(imported_mod)
-
-            if imp_node.is_absorb:
-                msg = f"\tRegistering module:{imported_mod.name} to "
-                msg += f"import_from (import all) handling with {imp_node.loc.mod_path}:{imp_node.loc}"
-
-                self.import_from_build_list.append((imp_node, imported_mod))
-            SymTabBuildPass(ir_in=imported_mod, prog=self.prog)
-
-    def __import_py_module(
-        self,
-        parent_node_path: str,
-        mod_path: str,
-        imported_mod_name: Optional[str] = None,
-    ) -> Optional[uni.Module]:
-        """Import a python module."""
-        from jaclang.compiler.passes.main import PyastBuildPass
-
-        python_raise_map = self.prog.py_raise_map
-        file_to_raise: Optional[str] = None
-
-        if mod_path in python_raise_map:
-            file_to_raise = python_raise_map[mod_path]
-        else:
-            # TODO: Is it fine to use imported_mod_name or get it from mod_path?
-            resolved_mod_path = f"{parent_node_path}.{mod_path}"
-            resolved_mod_path = resolved_mod_path.replace("..", ".")
-            resolved_mod_path = resolved_mod_path.replace(
-                f"{list(self.prog.mod.hub.values())[0]}.", ""
-            )
-            file_to_raise = python_raise_map.get(resolved_mod_path)
-
-        if file_to_raise is None:
-            return None
-
-        try:
-            if file_to_raise in {None, "built-in", "frozen"}:
-                return None
-
-            with open(file_to_raise, "r", encoding="utf-8") as f:
-                file_source = f.read()
-                mod = PyastBuildPass(
-                    ir_in=uni.PythonModuleAst(
-                        py_ast.parse(file_source),
-                        orig_src=uni.Source(file_source, file_to_raise),
-                    ),
-                    prog=self.prog,
-                ).ir_out
-
-            if mod:
-                mod.name = imported_mod_name if imported_mod_name else mod.name
-                if mod.name == "__init__":
-                    # (thakee): This needs to be re-done after implementing path handling properly.
-                    mod_name = mod.loc.mod_path.split(os.path.sep)[-2]
-                    mod.name = mod_name
-                    mod.scope_name = mod_name
-                mod.is_raised_from_py = True
-                return mod
-            else:
-                raise self.ice(f"\tFailed to import python module {mod_path}")
-
-        except Exception as e:
-            self.log_error(f"\tFailed to import python module {mod_path}")
-            raise e
-
-    def __load_builtins(self) -> None:
-        """Load Python builtins using introspection."""
-        import builtins
-        import inspect
-        from jaclang.compiler.passes.main import PyastBuildPass
-
-        # Python constants that cannot be assigned to
-        constants = {"True", "False", "None", "NotImplemented", "Ellipsis", "..."}
-
-        # Create a synthetic source with all builtins
-        builtin_items = []
-        for name in dir(builtins):
-            if name in constants:
-                # Skip constants as they're built into Python
-                continue
-
-            if not name.startswith("_") or name in ("__import__", "__build_class__"):
-                obj = getattr(builtins, name)
-                # Generate appropriate stub definitions based on obj type
-                if inspect.isclass(obj):
-                    builtin_items.append(f"class {name}: ...")
-                elif inspect.isfunction(obj) or inspect.isbuiltin(obj):
-                    # Try to get signature safely, use generic signature if it fails
-                    try:
-                        sig = inspect.signature(obj) if callable(obj) else "()"
-                        builtin_items.append(f"def {name}{sig}: ...")
-                    except (ValueError, TypeError):
-                        builtin_items.append(f"def {name}(*args, **kwargs): ...")
-                else:
-                    # For variables that are not constants
-                    builtin_items.append(f"{name} = None")
-
-        file_source = "\n".join(builtin_items)
-        mod = PyastBuildPass(
-            ir_in=uni.PythonModuleAst(
-                py_ast.parse(file_source),
-                orig_src=uni.Source(file_source, "builtins"),
-            ),
-            prog=self.prog,
-        ).ir_out
-        SymTabBuildPass(ir_in=mod, prog=self.prog)
-        self.prog.mod.hub["builtins"] = mod
-        mod.is_raised_from_py = True
-
-    def annex_impl(self, node: uni.Module) -> None:
-        """Annex impl and test modules."""
-        return None
-
-    def __handle_different_site_packages(self, mod_path: str) -> str:
-        if "site-packages" in mod_path:
-            mod_path = mod_path[mod_path.index("site-packages") :]
-        return mod_path
-
-    def __check_cyclic_imports(
-        self, imp_node: uni.UniNode, imported_module: uni.Module
-    ) -> bool:
-        """Check cyclic imports that might happen."""
-        # Example of cyclic imports is import os
-        # In the os stub file it imports the real os module which will cause os
-        # stub to be raised again and so on
-        # Another example is numpy. numpy init file imports multidim array file
-        # which imports again more items from numpy and so on.
-        imp_node_file = self.__handle_different_site_packages(imp_node.loc.mod_path)
-        imported_module_file = self.__handle_different_site_packages(
-            imported_module.loc.mod_path
-        )
-        if imp_node_file == imported_module_file:
-            return True
-
-        parent: Optional[uni.UniNode] = imp_node.parent
-        while parent is not None:
-            parent_file = self.__handle_different_site_packages(parent.loc.mod_path)
-            if parent_file == imported_module_file:
-                return True
-            else:
-                parent = parent.find_parent_of_type(uni.Module)
-
-        return False

jaclang/compiler/passes/main/inheritance_pass.py

@@ -60,11 +60,18 @@ class InheritancePass(Transform[uni.Module, uni.Module]):
         if base_class_symbol is None:
             return
 
-        base_class_symbol_table = base_class_symbol.fetch_sym_tab
+        base_class_symbol_table = base_class_symbol.symbol_table
+
+        # FIXME: If the base class symbol is imported from another module, the symbol table
+        # will be None. The imported symbols were ignored and introduced in the typecheck
+        # for imported module items. This needs to be investigated to ensure that even imported
+        # classes should have a symbol table (unless the module is not parsed and decided not to).
+        if base_class_symbol_table is None:
+            return
 
         if self.is_missing_py_symbol_table(base_class_symbol, base_class_symbol_table):
             return
-        assert base_class_symbol_table is not None
+
         node.sym_tab.inherit_sym_tab(base_class_symbol_table)
 
     def inherit_from_atom_trailer(
@@ -77,7 +84,7 @@ class InheritancePass(Transform[uni.Module, uni.Module]):
                 sym = self.lookup_symbol(name.sym_name, current_sym_table)
                 if sym is None:
                     return
-                current_sym_table = sym.fetch_sym_tab
+                current_sym_table = sym.symbol_table
                 # Handle Python base classes or index slice expressions
                 if self.is_missing_py_symbol_table(sym, current_sym_table):
                     return

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -187,6 +187,15 @@ class PyastGenPass(UniPass):
             ),
         )
 
+    def needs_mtllm(self) -> None:
+        """Ensure byLLM is imported only once."""
+        self._add_preamble_once(
+            self.needs_mtllm.__name__,
+            ast3.Import(
+                names=[self.sync(ast3.alias(name="byllm"), jac_node=self.ir_out)]
+            ),
+        )
+
     def needs_enum(self) -> None:
         """Ensure Enum utilities are imported only once."""
         self._add_preamble_once(
@@ -641,15 +650,13 @@ class PyastGenPass(UniPass):
             self.traverse(node.body)
 
     def exit_archetype(self, node: uni.Archetype) -> None:
-        inner = None
+        inner: Sequence[uni.CodeBlockStmt] | Sequence[uni.EnumBlockStmt] | None = None
         if isinstance(node.body, uni.ImplDef):
-            inner = (
-                node.body.body if not isinstance(node.body.body, uni.FuncCall) else None
-            )
-        elif not isinstance(node.body, uni.FuncCall):
+            inner = node.body.body if not isinstance(node.body.body, uni.Expr) else None
+        elif not isinstance(node.body, uni.Expr):
             inner = node.body
-        body = self.resolve_stmt_block(inner, doc=node.doc)
-        if not body and not isinstance(node.body, uni.FuncCall):
+        body: list[ast3.AST] = self.resolve_stmt_block(inner, doc=node.doc)
+        if not body and not isinstance(node.body, uni.Expr):
             self.log_error(
                 "Archetype has no body. Perhaps an impl must be imported.", node
             )
@@ -699,12 +706,10 @@ class PyastGenPass(UniPass):
 
     def exit_enum(self, node: uni.Enum) -> None:
         self.needs_enum()
-        inner = None
+        inner: Sequence[uni.CodeBlockStmt] | Sequence[uni.EnumBlockStmt] | None = None
         if isinstance(node.body, uni.ImplDef):
-            inner = (
-                node.body.body if not isinstance(node.body.body, uni.FuncCall) else None
-            )
-        elif not isinstance(node.body, uni.FuncCall):
+            inner = node.body.body if not isinstance(node.body.body, uni.Expr) else None
+        elif not isinstance(node.body, uni.Expr):
             inner = node.body
         body = self.resolve_stmt_block(inner, doc=node.doc)
         decorators = (
@@ -739,17 +744,25 @@ class PyastGenPass(UniPass):
         self, model: ast3.expr, caller: ast3.expr, args: ast3.Dict
     ) -> ast3.Call:
         """Reusable method to codegen call_llm(model, caller, args)."""
-        return self.sync(
+        self.needs_mtllm()
+        mtir_cls_ast = self.sync(
+            ast3.Attribute(
+                value=self.sync(ast3.Name(id="byllm", ctx=ast3.Load())),
+                attr="MTIR",
+                ctx=ast3.Load(),
+            )
+        )
+        mtir_ast = self.sync(
             ast3.Call(
-                func=self.jaclib_obj("call_llm"),
+                func=self.sync(
+                    ast3.Attribute(
+                        value=mtir_cls_ast,
+                        attr="factory",
+                        ctx=ast3.Load(),
+                    )
+                ),
                 args=[],
                 keywords=[
-                    self.sync(
-                        ast3.keyword(
-                            arg="model",
-                            value=model,
-                        )
-                    ),
                     self.sync(
                         ast3.keyword(
                             arg="caller",
@@ -762,45 +775,45 @@ class PyastGenPass(UniPass):
                             value=args,
                         )
                     ),
+                    self.sync(
+                        ast3.keyword(
+                            arg="call_params",
+                            value=self.sync(
+                                ast3.Attribute(
+                                    value=model,
+                                    attr="call_params",
+                                    ctx=ast3.Load(),
+                                ),
+                            ),
+                        )
+                    ),
+                ],
+            )
+        )
+        return self.sync(
+            ast3.Call(
+                func=self.jaclib_obj("call_llm"),
+                args=[],
+                keywords=[
+                    self.sync(
+                        ast3.keyword(
+                            arg="model",
+                            value=model,
+                        )
+                    ),
+                    self.sync(
+                        ast3.keyword(
+                            arg="mtir",
+                            value=mtir_ast,
+                        )
+                    ),
                 ],
             )
         )
-
-    def gen_llm_call_override(self, node: uni.FuncCall) -> list[ast3.AST]:
-        """Generate python ast nodes for llm function body override syntax.
-
-        example:
-            foo() by llm();
-        """
-        # from jaclang.runtimelib.machine import JacMachineInterface
-        # return JacMachineInterface.gen_llm_call_override(self, node)
-        if node.body_genai_call is None:
-            raise self.ice()
-
-        model = cast(ast3.expr, node.body_genai_call.gen.py_ast[0])
-        caller = cast(ast3.expr, node.target.gen.py_ast[0])
-
-        # Construct the arguments for the LLM call.
-        keys: list[ast3.expr | None] = []
-        values: list[ast3.expr] = []
-        for idx, call_arg in enumerate(node.params):
-            if isinstance(call_arg, uni.Expr):
-                keys.append(self.sync(ast3.Constant(value=idx)))
-                values.append(cast(ast3.expr, call_arg.gen.py_ast[0]))
-            else:
-                if call_arg.key:
-                    keys.append(self.sync(ast3.Constant(value=call_arg.key.sym_name)))
-                else:
-                    keys.append(self.sync(ast3.Constant(value=idx)))
-                values.append(cast(ast3.expr, call_arg.value.gen.py_ast[0]))
-
-        args = self.sync(ast3.Dict(keys=keys, values=values))
-
-        return [self._invoke_llm_call(model, caller, args)]
 
     def gen_llm_body(self, node: uni.Ability) -> list[ast3.stmt]:
         """Generate the by LLM body."""
-        assert isinstance(node.body, uni.FuncCall)
+        assert isinstance(node.body, uni.Expr)
         assert isinstance(node.signature, uni.FuncSignature)
 
         # Codegen for the caller of the LLM call.
@@ -865,10 +878,10 @@ class PyastGenPass(UniPass):
         func_type = ast3.AsyncFunctionDef if node.is_async else ast3.FunctionDef
         body = (
             self.gen_llm_body(node)
-            if isinstance(node.body, uni.FuncCall)
+            if isinstance(node.body, uni.Expr)
             or (
                 isinstance(node.body, uni.ImplDef)
-                and isinstance(node.body.body, uni.FuncCall)
+                and isinstance(node.body.body, uni.Expr)
             )
             else (
                 [
@@ -886,10 +899,10 @@ class PyastGenPass(UniPass):
                         (
                             node.body.body
                             if isinstance(node.body, uni.ImplDef)
-                            and not isinstance(node.body.body, uni.FuncCall)
+                            and not isinstance(node.body.body, uni.Expr)
                             else (
                                 node.body
-                                if not isinstance(node.body, uni.FuncCall)
+                                if not isinstance(node.body, uni.Expr)
                                 else None
                             )
                         ),
@@ -939,7 +952,7 @@ class PyastGenPass(UniPass):
             decorator_list.insert(
                 0, self.sync(ast3.Name(id="staticmethod", ctx=ast3.Load()))
             )
-        if not body and not isinstance(node.body, uni.FuncCall):
+        if not body and not isinstance(node.body, uni.Expr):
             self.log_error(
                 "Ability has no body. Perhaps an impl must be imported.", node
             )
@@ -1074,18 +1087,20 @@ class PyastGenPass(UniPass):
             ]
 
     def exit_param_var(self, node: uni.ParamVar) -> None:
-        node.gen.py_ast = [
-            self.sync(
-                ast3.arg(
-                    arg=node.name.sym_name,
-                    annotation=(
-                        cast(ast3.expr, node.type_tag.gen.py_ast[0])
-                        if node.type_tag
-                        else None
-                    ),
+        if isinstance(node.name.gen.py_ast[0], ast3.Name):
+            name = node.name.gen.py_ast[0].id
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.arg(
+                        arg=name,
+                        annotation=(
+                            cast(ast3.expr, node.type_tag.gen.py_ast[0])
+                            if node.type_tag
+                            else None
+                        ),
+                    )
                 )
-            )
-        ]
+            ]
 
     def exit_arch_has(self, node: uni.ArchHas) -> None:
         vars_py: list[ast3.AST] = self.flatten([v.gen.py_ast for v in node.vars])
@@ -2297,7 +2312,11 @@ class PyastGenPass(UniPass):
         node.gen.py_ast = [
             self.sync(
                 ast3.keyword(
-                    arg=node.key.sym_name if node.key else None,
+                    arg=(
+                        node.key.gen.py_ast[0].id
+                        if node.key and isinstance(node.key.gen.py_ast[0], ast3.Name)
+                        else None
+                    ),
                     value=cast(ast3.expr, node.value.gen.py_ast[0]),
                 )
             )
@@ -2492,11 +2511,8 @@ class PyastGenPass(UniPass):
         return args, keywords
 
     def exit_func_call(self, node: uni.FuncCall) -> None:
-        if node.body_genai_call:
-            node.gen.py_ast = self.gen_llm_call_override(node)
-
         # TODO: This needs to be changed to only generate parameters no the body.
-        elif node.genai_call:
+        if node.genai_call:
             self.ice("Type(by llm()) call feature is temporarily disabled.")
 
         else:
@@ -2981,9 +2997,8 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [self.sync(op_cls())]
 
     def exit_name(self, node: uni.Name) -> None:
-        node.gen.py_ast = [
-            self.sync(ast3.Name(id=node.sym_name, ctx=node.py_ctx_func()))
-        ]
+        name = node.sym_name[2:] if node.sym_name.startswith("<>") else node.sym_name
+        node.gen.py_ast = [self.sync(ast3.Name(id=name, ctx=node.py_ctx_func()))]
 
     def exit_float(self, node: uni.Float) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=float(node.value)))]

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -1374,10 +1374,11 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
         valid = [
             value for value in values if isinstance(value, (uni.String, uni.ExprStmt))
         ]
-        return uni.FString(
+        fstr = uni.FString(
             parts=valid,
             kid=[*valid] if valid else [uni.EmptyToken()],
         )
+        return uni.MultiString(strings=[fstr], kid=[fstr])
 
     def proc_lambda(self, node: py_ast.Lambda) -> uni.LambdaExpr:
         """Process python node.
@@ -2337,20 +2338,30 @@ class PyastBuildPass(Transform[uni.PythonModuleAst, uni.Module]):
         arg: _Identifier | None
         value: expr
         """
-        arg = uni.Name(
-            orig_src=self.orig_src,
-            name=Tok.NAME,
-            value=node.arg if node.arg else "_",
-            line=node.lineno,
-            end_line=node.end_lineno if node.end_lineno else node.lineno,
-            col_start=node.col_offset,
-            col_end=node.col_offset + len(node.arg if node.arg else "_"),
-            pos_start=0,
-            pos_end=0,
-        )
+        arg = None
+        if node.arg:
+            from jaclang.compiler import TOKEN_MAP
+
+            reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+            arg_value = (
+                node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
+            )
+            arg = uni.Name(
+                orig_src=self.orig_src,
+                name=Tok.NAME,
+                value=arg_value,
+                line=node.lineno,
+                end_line=node.end_lineno if node.end_lineno else node.lineno,
+                col_start=node.col_offset,
+                col_end=node.col_offset + len(node.arg if node.arg else "_"),
+                pos_start=0,
+                pos_end=0,
+            )
         value = self.convert(node.value)
         if isinstance(value, uni.Expr):
-            return uni.KWPair(key=arg, value=value, kid=[arg, value])
+            return uni.KWPair(
+                key=arg, value=value, kid=[arg, value] if arg else [value]
+            )
         else:
             raise self.ice()
 

jaclang/compiler/passes/main/sem_def_match_pass.py

@@ -47,7 +47,7 @@ class SemDefMatchPass(Transform[uni.Module, uni.Module]):
             sym = current_sym_tab.lookup(part, deep=False)
             if sym is None:
                 return None
-            current_sym_tab = sym.fetch_sym_tab
+            current_sym_tab = sym.symbol_table
         return sym
 
     def connect_sems(

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -84,6 +84,10 @@ class SymTabBuildPass(UniPass):
         else:
             pass  # Need to support pythonic import symbols with dots in it
 
+    def exit_module_item(self, node: uni.ModuleItem) -> None:
+        sym_node = node.alias or node.name
+        sym_node.sym_tab.def_insert(sym_node, single_decl="import")
+
     def enter_archetype(self, node: uni.Archetype) -> None:
         self.push_scope_and_link(node)
         assert node.parent_scope is not None

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

@@ -0,0 +1,3 @@
+
+
+glob k = 19;

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

@@ -0,0 +1,12 @@
+obj Rock {
+    has pellets:list;
+
+    def count_pellets() -> int {
+        return self.pellets.length();
+    }
+}
+
+with entry {
+    rock = Rock(pellets=[1, 2, 3]);
+    print("Number of pellets: " + rock.count_pellets().to_string());
+}