jaclang 0.7.9__py3-none-any.whl → 0.7.13__py3-none-any.whl

jaclang/langserve/tests/test_server.py

@@ -39,36 +39,6 @@ class TestJacLangServer(TestCase):
                 ],
             )
 
-    def test_syntax_diagnostics(self) -> None:
-        """Test diagnostics."""
-        lsp = JacLangServer()
-        # Set up the workspace path to "fixtures/"
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        circle_file = uris.from_fs_path(self.fixture_abs_path("circle_err.jac"))
-        lsp.quick_check(circle_file)
-        self.assertEqual(len(lsp.modules), 1)
-        self.assertEqual(lsp.modules[circle_file].diagnostics[0].range.start.line, 22)
-
-    def test_doesnt_run_if_syntax_error(self) -> None:
-        """Test that the server doesn't run if there is a syntax error."""
-        lsp = JacLangServer()
-        # Set up the workspace path to "fixtures/"
-        workspace_path = self.fixture_abs_path("")
-        workspace = Workspace(workspace_path, lsp)
-        lsp.lsp._workspace = workspace
-        circle_file = uris.from_fs_path(self.fixture_abs_path("circle_err.jac"))
-        lsp.quick_check(circle_file)
-        self.assertEqual(len(lsp.modules), 1)
-        self.assertEqual(lsp.modules[circle_file].diagnostics[0].range.start.line, 22)
-        lsp.deep_check(circle_file)
-        # self.assertEqual(len(lsp.modules), 1)
-        self.assertEqual(lsp.modules[circle_file].diagnostics[0].range.start.line, 22)
-        lsp.type_check(circle_file)
-        # self.assertEqual(len(lsp.modules), 1)
-        self.assertEqual(lsp.modules[circle_file].diagnostics[0].range.start.line, 22)
-
     def test_impl_stay_connected(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()
@@ -80,15 +50,13 @@ class TestJacLangServer(TestCase):
         circle_impl_file = uris.from_fs_path(
             self.fixture_abs_path("circle_pure.impl.jac")
         )
-        lsp.quick_check(circle_file)
         lsp.deep_check(circle_file)
-        lsp.type_check(circle_file)
         pos = lspt.Position(20, 8)
         self.assertIn(
             "Circle class inherits from Shape.",
             lsp.get_hover_info(circle_file, pos).contents.value,
         )
-        lsp.type_check(circle_impl_file)
+        lsp.deep_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
             "ability) calculate_area: float",
@@ -105,9 +73,7 @@ class TestJacLangServer(TestCase):
         circle_impl_file = uris.from_fs_path(
             self.fixture_abs_path("circle_pure.impl.jac")
         )
-        lsp.quick_check(circle_impl_file)
         lsp.deep_check(circle_impl_file)
-        lsp.type_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
             "ability) calculate_area: float",
@@ -121,12 +87,8 @@ class TestJacLangServer(TestCase):
         workspace_path = self.fixture_abs_path("")
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
-        target = uris.from_fs_path(
-            self.fixture_abs_path("../../../../examples/guess_game/guess_game4.jac")
-        )
-        lsp.quick_check(target)
+        target = uris.from_fs_path(self.examples_abs_path("guess_game/guess_game4.jac"))
         lsp.deep_check(target)
-        lsp.type_check(target)
         pos = lspt.Position(43, 18)
         self.assertIn(
             "attempts: int",
@@ -140,9 +102,7 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.jac"))
-        lsp.quick_check(circle_file)
         lsp.deep_check(circle_file)
-        lsp.type_check(circle_file)
         self.assertEqual(8, len(lsp.get_document_symbols(circle_file)))
 
     def test_go_to_definition(self) -> None:
@@ -152,9 +112,7 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.jac"))
-        lsp.quick_check(circle_file)
         lsp.deep_check(circle_file)
-        lsp.type_check(circle_file)
         self.assertIn(
             "fixtures/circle_pure.impl.jac:8:0-8:19",
             str(lsp.get_definition(circle_file, lspt.Position(9, 16))),
@@ -171,11 +129,9 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         guess_game_file = uris.from_fs_path(
-            self.fixture_abs_path("../../../../examples/guess_game/guess_game4.jac")
+            self.examples_abs_path("guess_game/guess_game4.jac")
         )
-        lsp.quick_check(guess_game_file)
         lsp.deep_check(guess_game_file)
-        lsp.type_check(guess_game_file)
         self.assertIn(
             "guess_game4.jac:27:8-27:21",
             str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
@@ -189,9 +145,7 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.test.jac"))
-        lsp.quick_check(circle_file)
         lsp.deep_check(circle_file)
-        lsp.type_check(circle_file)
         pos = lspt.Position(13, 29)
         self.assertIn(
             "shape_type: circle_pure.ShapeType",
@@ -207,13 +161,11 @@ class TestJacLangServer(TestCase):
         import_file = uris.from_fs_path(
             self.fixture_abs_path("import_include_statements.jac")
         )
-        lsp.quick_check(import_file)
         lsp.deep_check(import_file)
-        lsp.type_check(import_file)
         positions = [
             (2, 16, "datetime.py:0:0-0:0"),
             (3, 17, "base_module_structure.jac:0:0-0:0"),
-            (3, 74, "base_module_structure.jac:23:0-23:5"),
+            (3, 87, "base_module_structure.jac:23:0-23:5"),
             (5, 65, "py_import.py:12:0-20:5"),
             (5, 35, "py_import.py:3:0-4:5"),
         ]
@@ -232,35 +184,90 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle.jac"))
-        lsp.quick_check(circle_file)
         lsp.deep_check(circle_file)
-        lsp.type_check(circle_file)
         sem_list = lsp.get_semantic_tokens(circle_file).data
         expected_counts = [
-            ("<JacSemTokenType.VARIABLE: 8>, <JacSemTokenModifier.READONLY: 4>", 206),
+            ("<JacSemTokenType.VARIABLE: 8>, <JacSemTokenModifier.READONLY: 4>", 12),
             (
                 "<JacSemTokenType.PROPERTY: 9>, <JacSemTokenModifier.DEFINITION: 2>,",
-                112,
+                19,
             ),
             (
                 "<JacSemTokenType.PARAMETER: 7>, <JacSemTokenModifier.DECLARATION: 1>,",
-                56,
+                5,
             ),
             (
                 "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
-                25,
+                9,
             ),
-            ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 12),
-            ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 37),
-            ("<JacSemTokenType.CLASS: 2>, <JacSemTokenModifier.DECLARATION: ", 162),
+            ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 6),
+            ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 4),
+            ("<JacSemTokenType.CLASS: 2>, <JacSemTokenModifier.DECLARATION: ", 12),
             (
                 "<JacSemTokenType.NAMESPACE: 0>, <JacSemTokenModifier.DEFINITION: 2>,",
-                10,
+                3,
             ),
-            ("0, 0, 4,", 22),
-            ("0, 0, 3,", 192),
-            ("0, 0, 6, ", 65),
-            (" 0, 7, 3,", 3),
         ]
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
+
+    def test_completion(self) -> None:
+        """Test that the completions are correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        base_module_file = uris.from_fs_path(
+            self.fixture_abs_path("base_module_structure.jac")
+        )
+        lsp.deep_check(base_module_file)
+        test_cases = [
+            (lspt.Position(37, 16), ["get_color1", "color1", "point1"], 3),
+            (
+                lspt.Position(51, 12),
+                [
+                    "get_color1",
+                    "color1",
+                    "point1",
+                    "base_colorred",
+                    "pointred",
+                    "color2",
+                ],
+                6,
+            ),
+            (lspt.Position(52, 19), ["color22", "point22"], 2),
+        ]
+        for position, expected_completions, expected_length in test_cases:
+            completions = lsp.get_completion(
+                base_module_file, position, completion_trigger="."
+            ).items
+            for completion in expected_completions:
+                self.assertIn(completion, str(completions))
+            self.assertEqual(expected_length, len(completions))
+
+            if position == lspt.Position(47, 12):
+                self.assertEqual(
+                    1, str(completions).count("kind=<CompletionItemKind.Function: 3>")
+                )
+                self.assertEqual(
+                    4, str(completions).count("kind=<CompletionItemKind.Field: 5>")
+                )
+
+    def test_go_to_reference(self) -> None:
+        """Test that the go to reference is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(self.fixture_abs_path("circle.jac"))
+        lsp.deep_check(circle_file)
+        test_cases = [
+            (47, 12, ["circle.jac:47:8-47:14", "69:8-69:14", "74:8-74:14"]),
+            (54, 66, ["54:62-54:76", "65:28-65:42"]),
+            (62, 14, ["65:49-65:62", "70:38-70:51"]),
+        ]
+        for line, char, expected_refs in test_cases:
+            references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
+            for expected in expected_refs:
+                self.assertIn(expected, references)

jaclang/langserve/utils.py

@@ -4,14 +4,18 @@ import asyncio
 import builtins
 import importlib.util
 import os
+import re
 import sys
 from functools import wraps
 from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.codeloc import CodeLocInfo
+from jaclang.compiler.constant import SymbolType
+from jaclang.compiler.passes.transform import Alert
 from jaclang.compiler.symtable import Symbol, SymbolTable
 from jaclang.utils.helpers import import_target_to_relative_path
+from jaclang.vendor.pygls import uris
 
 import lsprotocol.types as lspt
 
@@ -19,6 +23,29 @@ T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
 P = ParamSpec("P")
 
 
+def gen_diagnostics(
+    from_path: str, errors: list[Alert], warnings: list[Alert]
+) -> list[lspt.Diagnostic]:
+    """Return diagnostics."""
+    return [
+        lspt.Diagnostic(
+            range=create_range(error.loc),
+            message=error.msg,
+            severity=lspt.DiagnosticSeverity.Error,
+        )
+        for error in errors
+        if error.loc.mod_path == uris.to_fs_path(from_path)
+    ] + [
+        lspt.Diagnostic(
+            range=create_range(warning.loc),
+            message=warning.msg,
+            severity=lspt.DiagnosticSeverity.Warning,
+        )
+        for warning in warnings
+        if warning.loc.mod_path == uris.to_fs_path(from_path)
+    ]
+
+
 def debounce(wait: float) -> Callable[[T], Callable[..., Awaitable[None]]]:
     """Debounce decorator for async functions."""
 
@@ -194,6 +221,49 @@ def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
     )
 
 
+def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind:
+    """Map the symbol node to an lspt.CompletionItemKind."""
+    return (
+        lspt.CompletionItemKind.Function
+        if sub_tab in [SymbolType.ABILITY, SymbolType.TEST]
+        else (
+            lspt.CompletionItemKind.Class
+            if sub_tab
+            in [
+                SymbolType.OBJECT_ARCH,
+                SymbolType.NODE_ARCH,
+                SymbolType.EDGE_ARCH,
+                SymbolType.WALKER_ARCH,
+            ]
+            else (
+                lspt.CompletionItemKind.Module
+                if sub_tab == SymbolType.MODULE
+                else (
+                    lspt.CompletionItemKind.Enum
+                    if sub_tab == SymbolType.ENUM_ARCH
+                    else (
+                        lspt.CompletionItemKind.Field
+                        if sub_tab == SymbolType.HAS_VAR
+                        else (
+                            lspt.CompletionItemKind.Method
+                            if sub_tab == SymbolType.METHOD
+                            else (
+                                lspt.CompletionItemKind.EnumMember
+                                if sub_tab == SymbolType.ENUM_MEMBER
+                                else (
+                                    lspt.CompletionItemKind.Interface
+                                    if sub_tab == SymbolType.IMPL
+                                    else lspt.CompletionItemKind.Variable
+                                )
+                            )
+                        )
+                    )
+                )
+            )
+        )
+    )
+
+
 def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None:
     """Get path for a module import name."""
     ret_target = None
@@ -292,3 +362,199 @@ def get_definition_range(
                         return filename, (start_line - 1, end_line - 1)
 
     return None
+
+
+def locate_affected_token(
+    tokens: list[int],
+    change_start_line: int,
+    change_start_char: int,
+    change_end_line: int,
+    change_end_char: int,
+) -> Optional[int]:
+    """Find in which token change is occurring."""
+    token_index = 0
+    current_line = 0
+    line_char_offset = 0
+
+    while token_index < len(tokens):
+        token_line_delta = tokens[token_index]
+        token_start_char = tokens[token_index + 1]
+        token_length = tokens[token_index + 2]
+
+        if token_line_delta > 0:
+            current_line += token_line_delta
+            line_char_offset = 0
+        token_abs_start_char = line_char_offset + token_start_char
+        token_abs_end_char = token_abs_start_char + token_length
+        if (
+            current_line == change_start_line == change_end_line
+            and token_abs_start_char <= change_start_char
+            and change_end_char <= token_abs_end_char
+        ):
+            return token_index
+        if (
+            current_line == change_start_line
+            and token_abs_start_char <= change_start_char < token_abs_end_char
+        ):
+            return token_index
+        if (
+            current_line == change_end_line
+            and token_abs_start_char < change_end_char <= token_abs_end_char
+        ):
+            return token_index
+
+        line_char_offset += token_start_char
+        token_index += 5
+    return None
+
+
+def collect_all_symbols_in_scope(
+    sym_tab: SymbolTable, up_tree: bool = True
+) -> list[lspt.CompletionItem]:
+    """Return all symbols in scope."""
+    symbols = []
+    visited = set()
+    current_tab: Optional[SymbolTable] = sym_tab
+
+    while current_tab is not None and current_tab not in visited:
+        visited.add(current_tab)
+        for name, symbol in current_tab.tab.items():
+            if name not in dir(builtins):
+                symbols.append(
+                    lspt.CompletionItem(label=name, kind=label_map(symbol.sym_type))
+                )
+        if not up_tree:
+            return symbols
+        current_tab = current_tab.parent if current_tab.parent != current_tab else None
+    return symbols
+
+
+def parse_symbol_path(text: str, dot_position: int) -> list[str]:
+    """Parse text and return a list of symbols."""
+    text = text[:dot_position].strip()
+    pattern = re.compile(r"\b\w+\(\)?|\b\w+\b")
+    matches = pattern.findall(text)
+    if text.endswith("."):
+        matches.append("")
+    symbol_path = []
+    i = 0
+    while i < len(matches):
+        if matches[i].endswith("("):
+            i += 1
+            continue
+        elif "(" in matches[i]:
+            symbol_path.append(matches[i])
+        elif matches[i] == "":
+            pass
+        else:
+            symbol_path.append(matches[i])
+        i += 1
+
+    return symbol_path
+
+
+def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str:
+    """Resolve symbol path."""
+    visited = set()
+    current_tab: Optional[SymbolTable] = node_tab
+
+    while current_tab is not None and current_tab not in visited:
+        visited.add(current_tab)
+        for name, symbol in current_tab.tab.items():
+            if name not in dir(builtins) and name == sym_name:
+                path = symbol.defn[0]._sym_type
+                return path
+        current_tab = current_tab.parent if current_tab.parent != current_tab else None
+    return ""
+
+
+def find_symbol_table(path: str, current_tab: Optional[SymbolTable]) -> SymbolTable:
+    """Find symbol table."""
+    path = path.lstrip(".")
+    current_table = current_tab
+    if current_table:
+        for segment in path.split("."):
+            current_table = next(
+                (
+                    child_table
+                    for child_table in current_table.kid
+                    if child_table.name == segment
+                ),
+                current_table,
+            )
+    if current_table:
+        return current_table
+    raise ValueError(f"Symbol table not found for path {path}")
+
+
+def resolve_completion_symbol_table(
+    mod_tab: SymbolTable,
+    current_symbol_path: list[str],
+    current_tab: Optional[SymbolTable],
+) -> list[lspt.CompletionItem]:
+    """Resolve symbol table for completion items."""
+    current_symbol_table = mod_tab
+    for obj in current_symbol_path:
+        if obj == "self":
+            try:
+                try:
+                    is_abilitydef = (
+                        mod_tab.owner
+                        if isinstance(mod_tab.owner, ast.AbilityDef)
+                        else mod_tab.owner.parent_of_type(ast.AbilityDef)
+                    )
+                    archi_owner = (
+                        (is_abilitydef.decl_link.parent_of_type(ast.Architype))
+                        if is_abilitydef.decl_link
+                        else None
+                    )
+                    current_symbol_table = (
+                        archi_owner._sym_tab
+                        if archi_owner and archi_owner._sym_tab
+                        else mod_tab
+                    )
+                    continue
+
+                except ValueError:
+                    pass
+                archi_owner = mod_tab.owner.parent_of_type(ast.Architype)
+                current_symbol_table = (
+                    archi_owner._sym_tab
+                    if archi_owner and archi_owner._sym_tab
+                    else mod_tab
+                )
+            except ValueError:
+                pass
+        else:
+            path: str = resolve_symbol_path(obj, current_symbol_table)
+            if path:
+                current_symbol_table = find_symbol_table(path, current_tab)
+            else:
+                if (
+                    isinstance(current_symbol_table.owner, ast.Architype)
+                    and current_symbol_table.owner.base_classes
+                ):
+                    for base_name in current_symbol_table.owner.base_classes.items:
+                        if isinstance(base_name, ast.Name) and base_name.sym:
+                            path = base_name.sym.sym_dotted_name + "." + obj
+                            current_symbol_table = find_symbol_table(path, current_tab)
+    if (
+        isinstance(current_symbol_table.owner, ast.Architype)
+        and current_symbol_table.owner.base_classes
+    ):
+        base = []
+        for base_name in current_symbol_table.owner.base_classes.items:
+            if isinstance(base_name, ast.Name) and base_name.sym:
+                base.append(base_name.sym.sym_dotted_name)
+        for base_ in base:
+            completion_items = collect_all_symbols_in_scope(
+                find_symbol_table(base_, current_tab),
+                up_tree=False,
+            )
+    else:
+        completion_items = []
+
+    completion_items.extend(
+        collect_all_symbols_in_scope(current_symbol_table, up_tree=False)
+    )
+    return completion_items

jaclang/plugin/default.py

@@ -213,8 +213,8 @@ class JacFeatureDefaults:
         override_name: Optional[str],
         mod_bundle: Optional[Module | str],
         lng: Optional[str],
-        items: Optional[dict[str, Union[str, bool]]],
-    ) -> Optional[types.ModuleType]:
+        items: Optional[dict[str, Union[str, Optional[str]]]],
+    ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         result = jac_importer(
             target=target,
@@ -251,9 +251,10 @@ class JacFeatureDefaults:
         maxfail: Optional[int],
         directory: Optional[str],
         verbose: bool,
-    ) -> bool:
+    ) -> int:
         """Run the test suite in the specified .jac file."""
         test_file = False
+        ret_count = 0
         if filepath:
             if filepath.endswith(".jac"):
                 base, mod_name = os.path.split(filepath)
@@ -262,6 +263,7 @@ class JacFeatureDefaults:
                 JacTestCheck.reset()
                 Jac.jac_import(target=mod_name, base_path=base)
                 JacTestCheck.run_test(xit, maxfail, verbose)
+                ret_count = JacTestCheck.failcount
             else:
                 print("Not a .jac file.")
         else:
@@ -293,10 +295,11 @@ class JacFeatureDefaults:
                 if JacTestCheck.breaker and (xit or maxfail):
                     break
             JacTestCheck.breaker = False
+            ret_count += JacTestCheck.failcount
             JacTestCheck.failcount = 0
             print("No test files found.") if not test_file else None
 
-        return True
+        return ret_count
 
     @staticmethod
     @hookimpl

jaclang/plugin/feature.py

@@ -104,8 +104,8 @@ class JacFeature:
         override_name: Optional[str] = None,
         mod_bundle: Optional[Module | str] = None,
         lng: Optional[str] = "jac",
-        items: Optional[dict[str, Union[str, bool]]] = None,
-    ) -> Optional[types.ModuleType]:
+        items: Optional[dict[str, Union[str, Optional[str]]]] = None,
+    ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         return pm.hook.jac_import(
             target=target,
@@ -132,7 +132,7 @@ class JacFeature:
         maxfail: Optional[int] = None,
         directory: Optional[str] = None,
         verbose: bool = False,
-    ) -> bool:
+    ) -> int:
         """Run the test suite in the specified .jac file."""
         return pm.hook.run_test(
             filepath=filepath,

jaclang/plugin/spec.py

@@ -101,8 +101,8 @@ class JacFeatureSpec:
         override_name: Optional[str],
         mod_bundle: Optional[Module | str],
         lng: Optional[str],
-        items: Optional[dict[str, Union[str, bool]]],
-    ) -> Optional[types.ModuleType]:
+        items: Optional[dict[str, Union[str, Optional[str]]]],
+    ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
         raise NotImplementedError
 
@@ -121,7 +121,7 @@ class JacFeatureSpec:
         maxfail: Optional[int],
         directory: Optional[str],
         verbose: bool,
-    ) -> bool:
+    ) -> int:
         """Run the test suite in the specified .jac file."""
         raise NotImplementedError
 

jaclang/settings.py

@@ -13,6 +13,7 @@ class Settings:
     fuse_type_info_debug: bool = False
     filter_sym_builtins: bool = True
     ast_symbol_info_detailed: bool = False
+    pass_timer: bool = False
 
     # Import configuration
     py_raise: bool = False

jaclang/tests/fixtures/deep/one_lev.jac

@@ -1,6 +1,8 @@
-import:jac deeper.snd_lev as snd_lev;
+import:jac from .deeper, snd_lev as snd_lev;
+import:jac from ..deep, deeper;
+import:jac from ., deeper as mydeeper;
 
-can olprint ->str {
+can olprint -> str {
+    # deeper.snd_lev.slprint(); FIXME:
     return "one level deeper" + snd_lev.slprint();
-}
-
+}

jaclang/tests/fixtures/needs_import.jac

@@ -1,11 +1,11 @@
 """Test of jac importing python."""
+
 import:py os;
 import:py pyfunc;
 import:py random;
 import:py from pyfunc, my_print;
 
 with entry {
-
     my_print(pyfunc);
     print(random.random());
 }