jaclang 0.7.11__py3-none-any.whl → 0.7.14__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",
@@ -122,9 +88,7 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         target = uris.from_fs_path(self.examples_abs_path("guess_game/guess_game4.jac"))
-        lsp.quick_check(target)
         lsp.deep_check(target)
-        lsp.type_check(target)
         pos = lspt.Position(43, 18)
         self.assertIn(
             "attempts: int",
@@ -138,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:
@@ -150,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,14 +131,36 @@ class TestJacLangServer(TestCase):
         guess_game_file = uris.from_fs_path(
             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))),
         )
 
+    def test_go_to_definition_method_manual_impl(self) -> None:
+        """Test that the go to definition is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        decldef_file = uris.from_fs_path(
+            self.examples_abs_path("micro/decl_defs_impl.jac")
+        )
+        lsp.deep_check(decldef_file)
+        self.assertNotIn(
+            "decl_defs_main.jac:8:8-8:17",
+            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
+        )
+        decldef_main_file = uris.from_fs_path(
+            self.examples_abs_path("micro/decl_defs_main.jac")
+        )
+        lsp.deep_check(decldef_main_file)
+        lsp.deep_check(decldef_file)
+        self.assertIn(
+            "decl_defs_main.jac:8:8-8:17",
+            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
+        )
+
     def test_test_annex(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()
@@ -187,9 +169,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",
@@ -205,13 +185,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"),
         ]
@@ -230,49 +208,84 @@ 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.quick_check(circle_file)
         lsp.deep_check(circle_file)
-        lsp.type_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"]),

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,
@@ -260,6 +260,8 @@ class JacFeatureDefaults:
                 base, mod_name = os.path.split(filepath)
                 base = base if base else "./"
                 mod_name = mod_name[:-4]
+                if mod_name.endswith(".test"):
+                    mod_name = mod_name[:-5]
                 JacTestCheck.reset()
                 Jac.jac_import(target=mod_name, base_path=base)
                 JacTestCheck.run_test(xit, maxfail, verbose)

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,

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
 

jaclang/tests/fixtures/blankwithentry.jac

@@ -0,0 +1,3 @@
+with entry:__main__ {}
+
+with entry {print("i work");}

jaclang/tests/fixtures/deep/one_lev.jac

@@ -1,5 +1,8 @@
 import:jac from .deeper, snd_lev as snd_lev;
+import:jac from ..deep, deeper;
+import:jac from ., deeper as mydeeper;
 
 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());
 }

jaclang/tests/test_cli.py

@@ -37,17 +37,16 @@ class JacCliTests(TestCase):
         sys.stdout = captured_output
         sys.stderr = captured_output
 
-        # Execute the function
-        # try:
-        cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])  # type: ignore
-        # except Exception as e:
-        #     print(f"Error: {e}")
+        try:
+            cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])  # type: ignore
+        except Exception as e:
+            print(f"Error: {e}")
 
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         # print(stdout_value)
-        self.assertIn("Errors occurred", stdout_value)
+        self.assertIn("Syntax Error", stdout_value)
 
     def test_jac_ast_tool_pass_template(self) -> None:
         """Basic test for pass."""
@@ -126,6 +125,7 @@ class JacCliTests(TestCase):
         cli.run(f"{self.fixture_abs_path('needs_import.jir')}")
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
+        print(stdout_value)
         self.assertIn("Errors: 0, Warnings: 0", stdout_value)
         self.assertIn("<module 'pyfunc' from", stdout_value)
 

jaclang/tests/test_language.py

@@ -840,3 +840,12 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[x()]", stdout_value)
+
+    def test_blank_with_entry(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("blankwithentry", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("i work", stdout_value)