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

jaclang/langserve/tests/session.jac

@@ -0,0 +1,294 @@
+"""Provides LSP session helpers for testing."""
+
+import os;
+import subprocess;
+import sys;
+import from concurrent.futures { Future, ThreadPoolExecutor } 
+import from threading { Event } 
+
+import from pylsp_jsonrpc.dispatchers { MethodDispatcher } 
+import from pylsp_jsonrpc.endpoint { Endpoint } 
+import from pylsp_jsonrpc.streams { JsonRpcStreamReader, JsonRpcStreamWriter } 
+
+import defaults;
+
+
+with entry {
+    LSP_EXIT_TIMEOUT = 5000;
+    PUBLISH_DIAGNOSTICS = 'textDocument/publishDiagnostics';
+    WINDOW_LOG_MESSAGE = 'window/logMessage';
+    WINDOW_SHOW_MESSAGE = 'window/showMessage';
+}
+
+
+"""Send and Receive messages over LSP as a test LS Client."""
+class LspSession (MethodDispatcher) {
+    def init(self: LspSession, cwd: Any = None) {
+        self.cwd = cwd if cwd else os.getcwd() ;
+        self._thread_pool = ThreadPoolExecutor();
+        self._sub = None;
+        self._writer = None;
+        self._reader = None;
+        self._endpoint = None;
+        self._notification_callbacks = {};
+    }
+    
+    """Context manager entrypoint.\n\n        shell=True needed for pytest-cov to work in subprocess.\n        """
+    def __enter__(self: LspSession) {
+        self._sub = subprocess.Popen(
+            ["jac", "run",
+            os.path.join(os.path.dirname(os.path.dirname(__file__)), 'server.jac')],
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            bufsize=0,
+            cwd=self.cwd,
+            env=os.environ,
+            shell=('WITH_COVERAGE' in os.environ)
+        );
+        self._writer = JsonRpcStreamWriter(os.fdopen(self._sub.stdin.fileno(), 'wb'));
+        self._reader = JsonRpcStreamReader(os.fdopen(self._sub.stdout.fileno(), 'rb'));
+        dispatcher = 
+        {PUBLISH_DIAGNOSTICS : self._publish_diagnostics , WINDOW_SHOW_MESSAGE : self._window_show_message , WINDOW_LOG_MESSAGE : self._window_log_message };
+        self._endpoint = Endpoint(dispatcher, self._writer.write);
+        self._thread_pool.submit(self._reader.listen, self._endpoint.consume);
+        return self;
+    }
+    
+    def __exit__(self: LspSession, typ: Any, value: Any, _tb: Any) {
+        self.shutdown(True);
+        try {
+            self._sub.terminate();
+        } except Exception as e {
+            
+        }
+        
+        self._endpoint.shutdown();
+        self._thread_pool.shutdown();
+    }
+    
+    """Sends the initialize request to LSP server."""
+    def initialize(
+        self: LspSession,
+        initialize_params: Any = None,
+        process_server_capabilities: Any = None
+    ) {
+        server_initialized = Event();
+        def _after_initialize(fut: Any) {
+            if process_server_capabilities {
+                process_server_capabilities(fut.result());
+            }
+            self.initialized();
+            server_initialized.set();
+        }
+        self._send_request(
+            'initialize',
+            params=initialize_params
+            if (initialize_params is not None)
+            else defaults.VSCODE_DEFAULT_INITIALIZE
+            ,
+            handle_response=_after_initialize
+        );
+        server_initialized.wait();
+    }
+    
+    """Sends the initialized notification to LSP server."""
+    def initialized(self: LspSession, initialized_params: Any = None) {
+        if (initialized_params is None) {
+            initialized_params = {};
+        }
+        self._endpoint.notify('initialized', initialized_params);
+    }
+    
+    """Sends the shutdown request to LSP server."""
+    def shutdown(
+        self: LspSession,
+        should_exit: Any,
+        exit_timeout: Any = LSP_EXIT_TIMEOUT
+    ) {
+        def _after_shutdown(_: Any) {
+            if should_exit {
+                self.exit_lsp(exit_timeout);
+            }
+        }
+        self._send_request('shutdown', handle_response=_after_shutdown);
+    }
+    
+    """Handles LSP server process exit."""
+    def exit_lsp(self: LspSession, exit_timeout: Any = LSP_EXIT_TIMEOUT) {
+        self._endpoint.notify('exit');
+        assert (self._sub.wait(exit_timeout) == 0) ;
+    }
+    
+    """Sends text document completion request to LSP server."""
+    def text_document_completion(self: LspSession, completion_params: Any) {
+        fut = self._send_request('textDocument/completion', params=completion_params);
+        return fut.result();
+    }
+    
+    """Sends text document rename request to LSP server."""
+    def text_document_rename(self: LspSession, rename_params: Any) {
+        fut = self._send_request('textDocument/rename', params=rename_params);
+        return fut.result();
+    }
+    
+    """Sends text document code action request to LSP server."""
+    def text_document_code_action(self: LspSession, code_action_params: Any) {
+        fut = self._send_request('textDocument/codeAction', params=code_action_params);
+        return fut.result();
+    }
+    
+    """Sends text document hover request to LSP server."""
+    def text_document_hover(self: LspSession, hover_params: Any) {
+        fut = self._send_request('textDocument/hover', params=hover_params);
+        return fut.result();
+    }
+    
+    """Sends text document formatting request to LSP server."""
+    def text_document_formatting(self: LspSession, formatting_params: Any) {
+        fut = self._send_request('textDocument/formatting', params=formatting_params);
+        return fut.result();
+    }
+    
+    """Sends text document hover request to LSP server."""
+    def text_document_signature_help(self: LspSession, signature_help_params: Any) {
+        fut = self._send_request(
+            'textDocument/signatureHelp',
+            params=signature_help_params
+        );
+        return fut.result();
+    }
+    
+    """Sends text document declaration request to LSP server."""
+    def text_document_declaration(self: LspSession, declaration_params: Any) {
+        fut = self._send_request('textDocument/declaration', params=declaration_params);
+        return fut.result();
+    }
+    
+    """Sends text document definition request to LSP server."""
+    def text_document_definition(self: LspSession, definition_params: Any) {
+        fut = self._send_request('textDocument/definition', params=definition_params);
+        return fut.result();
+    }
+    
+    """Sends text document symbol request to LSP server."""
+    def text_document_symbol(self: LspSession, document_symbol_params: Any) {
+        fut = self._send_request(
+            'textDocument/documentSymbol',
+            params=document_symbol_params
+        );
+        return fut.result();
+    }
+    
+    """Sends text document highlight request to LSP server."""
+    def text_document_highlight(self: LspSession, document_highlight_params: Any) {
+        fut = self._send_request(
+            'textDocument/documentHighlight',
+            params=document_highlight_params
+        );
+        return fut.result();
+    }
+    
+    """Sends text document references request to LSP server."""
+    def text_document_references(self: LspSession, references_params: Any) {
+        fut = self._send_request('textDocument/references', params=references_params);
+        return fut.result();
+    }
+    
+    """Sends workspace symbol request to LSP server."""
+    def workspace_symbol(self: LspSession, workspace_symbol_params: Any) {
+        fut = self._send_request('workspace/symbol', params=workspace_symbol_params);
+        return fut.result();
+    }
+    
+    """Sends completion item resolve request to LSP server."""
+    def completion_item_resolve(self: LspSession, resolve_params: Any) {
+        fut = self._send_request('completionItem/resolve', params=resolve_params);
+        return fut.result();
+    }
+    
+    """Sends did change notification to LSP Server."""
+    def notify_did_change(self: LspSession, did_change_params: Any) {
+        self._send_notification('textDocument/didChange', params=did_change_params);
+    }
+    
+    """Sends did save notification to LSP Server."""
+    def notify_did_save(self: LspSession, did_save_params: Any) {
+        self._send_notification('textDocument/didSave', params=did_save_params);
+    }
+    
+    """Sends did open notification to LSP Server."""
+    def notify_did_open(self: LspSession, did_open_params: Any) {
+        self._send_notification('textDocument/didOpen', params=did_open_params);
+    }
+    
+    """Set custom LS notification handler."""
+    def set_notification_callback(
+        self: LspSession,
+        notification_name: Any,
+        callback: Any
+    ) {
+        self._notification_callbacks[notification_name] = callback;
+    }
+    
+    """Gets callback if set or default callback for a given LS notification."""
+    def get_notification_callback(self: LspSession, notification_name: Any) {
+        try {
+            return self._notification_callbacks[notification_name];
+        } except KeyError {
+            def _default_handler(_params: Any) -> None {}
+            return _default_handler;
+        }
+        
+    }
+    
+    """Internal handler for text document publish diagnostics."""
+    def _publish_diagnostics(self: LspSession, publish_diagnostics_params: Any) {
+        return self._handle_notification(
+            PUBLISH_DIAGNOSTICS,
+            publish_diagnostics_params
+        );
+    }
+    
+    """Internal handler for window log message."""
+    def _window_log_message(self: LspSession, window_log_message_params: Any) {
+        return self._handle_notification(WINDOW_LOG_MESSAGE, window_log_message_params);
+    }
+    
+    """Internal handler for window show message."""
+    def _window_show_message(self: LspSession, window_show_message_params: Any) {
+        return self._handle_notification(
+            WINDOW_SHOW_MESSAGE,
+            window_show_message_params
+        );
+    }
+    
+    """Internal handler for notifications."""
+    def _handle_notification(self: LspSession, notification_name: Any, params: Any) {
+        fut = Future();
+        def _handler() {
+            callback = self.get_notification_callback(notification_name);
+            callback(params);
+            fut.set_result(None);
+        }
+        self._thread_pool.submit(_handler);
+        return fut;
+    }
+    
+    """Sends {name} request to the LSP server."""
+    def _send_request(
+        self: LspSession,
+        name: Any,
+        params: Any = None,
+        handle_response: Any = lambda  f: Any: f.done()
+    ) {
+        fut = self._endpoint.request(name, params);
+        fut.add_done_callback(handle_response);
+        return fut;
+    }
+    
+    """Sends {name} notification to the LSP server."""
+    def _send_notification(self: LspSession, name: Any, params: Any = None) {
+        self._endpoint.notify(name, params);
+    }
+}

jaclang/langserve/tests/test_sem_tokens.py

@@ -2,12 +2,12 @@
 
 import copy
 import lsprotocol.types as lspt
-
-from jaclang.langserve.sem_manager import SemTokManager
+from jaclang import JacMachineInterface as _
 from jaclang.utils.test import TestCase
 
 from typing import Tuple
 
+SemTokManager = _.py_jac_import("..sem_manager", __file__, items={"SemTokManager": None})[0]
 
 class TestUpdateSemTokens(TestCase):
     """Test update semantic tokens"""

jaclang/langserve/tests/test_server.py

@@ -1,12 +1,17 @@
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
-from jaclang.langserve.engine import JacLangServer
-from .session import LspSession
 
 import lsprotocol.types as lspt
 import pytest
+from jaclang import JacMachineInterface as _
 
+JacLangServer = _.py_jac_import(
+    "...langserve.engine", __file__, items={"JacLangServer": None}
+)[0]
+LspSession = _.py_jac_import(
+    "session", __file__, items={"LspSession": None}
+)[0]
 
 class TestJacLangServer(TestCase):
 
@@ -62,7 +67,7 @@ class TestJacLangServer(TestCase):
         self.assertIn(
             # "ability) calculate_area: float",
             "ability) calculate_area\n( radius : float ) -> float",
-            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+            lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
     def test_impl_auto_discover(self) -> None:
@@ -80,7 +85,7 @@ class TestJacLangServer(TestCase):
         self.assertIn(
             # "ability) calculate_area: float",
             "(public ability) calculate_area\n( radius : float ) -> float",
-            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+            lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
     @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
@@ -133,12 +138,12 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         guess_game_file = uris.from_fs_path(
-            self.examples_abs_path("guess_game/guess_game4.jac")
+            self.examples_abs_path("guess_game/guess_game4.impl.jac")
         )
         lsp.deep_check(guess_game_file)
         self.assertIn(
-            "guess_game4.jac:27:8-27:21",
-            str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
+            "guess_game4.jac:16:8-16:21",
+            str(lsp.get_definition(guess_game_file, lspt.Position(14, 45))),
         )
 
     def test_go_to_definition_method_manual_impl(self) -> None:

jaclang/langserve/utils.jac

@@ -24,10 +24,8 @@ import from jaclang.vendor.pygls { uris }
 import lsprotocol.types as lspt;
 
 
-with entry {
-    P = ParamSpec('P');
-    T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
-}
+glob P = ParamSpec('P');
+glob T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
 
 
 """Return diagnostics."""
@@ -36,11 +34,15 @@ def gen_diagnostics(
     errors: <>list[Alert],
     warnings: <>list[Alert]
 ) -> <>list[lspt.Diagnostic] {
-    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) ]);
+    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) ];
 }
 
 
@@ -156,25 +158,31 @@ def get_symbols_for_outline(<>node: UniScopeNode) -> <>list[lspt.DocumentSymbol]
             continue;
         }
         pos = create_range(item.decl.loc);
-        symbol = lspt.DocumentSymbol(name=key,
-        kind=kind_map(item.decl),
-        range=pos,
-        selection_range=pos,
-        children=[]);
+        symbol = lspt.DocumentSymbol(
+            name=key,
+            kind=kind_map(item.decl),
+            range=pos,
+            selection_range=pos,
+            children=[]
+        );
         symbols.append(symbol);
     }
     for sub_tab in [ i for i in <>node.kid_scope if i.loc.mod_path == <>node.loc.mod_path ] {
         sub_symbols = get_symbols_for_outline(sub_tab);
-        if isinstance(sub_tab,
-        (uni.IfStmt, uni.ElseStmt, uni.WhileStmt, uni.IterForStmt, uni.InForStmt)) {
+        if isinstance(
+            sub_tab,
+            (uni.IfStmt, uni.ElseStmt, uni.WhileStmt, uni.IterForStmt, uni.InForStmt)
+        ) {
             symbols.extend(sub_symbols);
         } else {
             sub_pos = create_range(sub_tab.loc);
-            symbol = lspt.DocumentSymbol(name=sub_tab.scope_name,
-            kind=kind_map(sub_tab),
-            range=sub_pos,
-            selection_range=sub_pos,
-            children=sub_symbols);
+            symbol = lspt.DocumentSymbol(
+                name=sub_tab.scope_name,
+                kind=kind_map(sub_tab),
+                range=sub_pos,
+                selection_range=sub_pos,
+                children=sub_symbols
+            );
             symbols.append(symbol);
         }
     }
@@ -193,10 +201,16 @@ def owner_sym(table: UniScopeNode) -> Optional[Symbol] {
 
 """Create an lspt.Range from a location object."""
 def create_range(loc: CodeLocInfo) -> lspt.Range {
-    return lspt.Range(start=lspt.Position(line=(loc.first_line - 1) if loc.first_line > 0 else 0 ,
-    character=(loc.col_start - 1) if loc.col_start > 0 else 0 ),
-    end=lspt.Position(line=(loc.last_line - 1) if loc.last_line > 0 else 0 ,
-    character=(loc.col_end - 1) if loc.col_end > 0 else 0 ));
+    return lspt.Range(
+        start=lspt.Position(
+            line=(loc.first_line - 1) if loc.first_line > 0 else 0 ,
+            character=(loc.col_start - 1) if loc.col_start > 0 else 0
+        ),
+        end=lspt.Position(
+            line=(loc.last_line - 1) if loc.last_line > 0 else 0 ,
+            character=(loc.col_end - 1) if loc.col_end > 0 else 0
+        )
+    );
 }
 
 
@@ -263,8 +277,9 @@ def collect_all_symbols_in_scope(
         visited.add(current_tab);
         for (name, symbol) in current_tab.names_in_scope.items() {
             if name not in dir(builtins) and symbol.sym_type != SymbolType.IMPL  {
-                symbols.append(lspt.CompletionItem(label=name,
-                kind=label_map(symbol.sym_type)));
+                symbols.append(
+                    lspt.CompletionItem(label=name, kind=label_map(symbol.sym_type))
+                );
             }
         }
         if not up_tree {
@@ -284,8 +299,12 @@ def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
     symbols : <>list[lspt.CompletionItem] = [];
     for tab in sym_tab.kid_scope {
         if tab.scope_name not in [ i.label for i in symbols ] {
-            symbols.append(lspt.CompletionItem(label=tab.scope_name,
-            kind=label_map(tab.get_type())));
+            symbols.append(
+                lspt.CompletionItem(
+                    label=tab.scope_name,
+                    kind=label_map(tab.get_type())
+                )
+            );
         }
     }
     return symbols;
@@ -368,7 +387,9 @@ def find_surrounding_tokens(
     prev_token_index = None;
     next_token_index = None;
     inside_tok = False;
-    for (i, tok) in enumerate([ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ][ 0 : ]) {
+    for (i, tok) in enumerate(
+        [ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ][ 0 : ]
+    ) {
         if (not (prev_token_index is None or next_token_index is None ))
         and (tok[0] > change_end_line
         or (tok[0] == change_end_line and tok[1] > change_end_char )

jaclang/runtimelib/archetype.py

@@ -223,7 +223,7 @@ class WalkerAnchor(Anchor):
 
     archetype: WalkerArchetype
     path: list[NodeAnchor] = field(default_factory=list)
-    next: list[NodeAnchor] = field(default_factory=list)
+    next: list[NodeAnchor | EdgeAnchor] = field(default_factory=list)
     ignores: list[NodeAnchor] = field(default_factory=list)
     disengaged: bool = False
 

jaclang/runtimelib/builtin.py

@@ -10,10 +10,7 @@ from jaclang.runtimelib.constructs import Archetype, NodeArchetype, Root
 from jaclang.runtimelib.machine import JacMachineInterface as Jac
 
 
-# FIXME: Retname this to something common, doing this way so this doesn't break
-# the existing code. Currently it can return the jac graph in both dot and json format.
-# So the name shuouldn't be dotgen but something more generic.
-def dotgen(
+def printgraph(
     node: Optional[NodeArchetype] = None,
     depth: int = -1,
     traverse: bool = False,
@@ -21,16 +18,17 @@ def dotgen(
     bfs: bool = True,
     edge_limit: int = 512,
     node_limit: int = 512,
-    dot_file: Optional[str] = None,
-    as_json: bool = False,
+    file: Optional[str] = None,
+    format: str = "dot",
 ) -> str:
-    """Print the dot graph."""
+    """Print the graph in different formats."""
     from jaclang.runtimelib.machine import JacMachineInterface as Jac
 
-    if as_json:
-        return _jac_graph_json()
+    fmt = format.lower()
+    if fmt == "json":
+        return _jac_graph_json(file)
 
-    return Jac.dotgen(
+    return Jac.printgraph(
         edge_type=edge_type,
         node=node or Jac.root(),
         depth=depth,
@@ -38,7 +36,8 @@ def dotgen(
         bfs=bfs,
         edge_limit=edge_limit,
         node_limit=node_limit,
-        dot_file=dot_file,
+        file=file,
+        format=fmt,
     )
 
 
@@ -52,7 +51,7 @@ def jobj(id: str) -> Archetype | None:
     return Jac.get_object(id)
 
 
-def _jac_graph_json() -> str:
+def _jac_graph_json(file: Optional[str] = None) -> str:
     """Get the graph in json string."""
     processed: list[Root | NodeArchetype] = []
     nodes: list[dict] = []
@@ -73,20 +72,24 @@ def _jac_graph_json() -> str:
         for ref in Jac.refs(end):
             if ref not in processed:
                 working_set.append((end, ref))
-    return json.dumps(
+    output = json.dumps(
         {
             "version": "1.0",
             "nodes": nodes,
             "edges": edges,
         }
     )
+    if file:
+        with open(file, "w") as f:
+            f.write(output)
+    return output
 
 
 __all__ = [
     "abstractmethod",
     "ClassVar",
     "override",
-    "dotgen",
+    "printgraph",
     "jid",
     "jobj",
 ]

jaclang/runtimelib/importer.py

@@ -102,14 +102,34 @@ class ImportReturn:
                 item = getattr(module, name)
                 handle_item_loading(item, alias)
             except AttributeError:
+                found = False
                 if lang == "jac":
                     jac_file_path = (
                         os.path.join(module.__path__[0], f"{name}.jac")
                         if hasattr(module, "__path__")
                         else module.__file__
                     )
-
-                    if jac_file_path and os.path.isfile(jac_file_path):
+                    if hasattr(module, "__path__"):
+                        init_jac = os.path.join(module.__path__[0], "__init__.jac")
+                        if os.path.isfile(init_jac):
+                            package_name = module.__name__
+                            init_mod = self.importer.jac_machine.loaded_modules.get(
+                                package_name,
+                                self.load_jac_mod_as_item(
+                                    module=module,
+                                    name="__init__",
+                                    jac_file_path=init_jac,
+                                ),
+                            )
+                            # Attach all public names from __init__.jac to the package module
+                            for k, v in init_mod.__dict__.items():
+                                if not k.startswith("_"):
+                                    setattr(module, k, v)
+                            if hasattr(module, name):
+                                item = getattr(module, name)
+                                handle_item_loading(item, alias)
+                                found = True
+                    if not found and jac_file_path and os.path.isfile(jac_file_path):
                         item = self.load_jac_mod_as_item(
                             module=module,
                             name=name,
@@ -144,9 +164,8 @@ class ImportReturn:
                         jac_file_path,
                     ),
                 )
-            codeobj = self.importer.jac_machine.jac_program.get_bytecode(
-                full_target=jac_file_path,
-                full_compile=not self.importer.jac_machine.interp_mode,
+            codeobj = self.importer.jac_machine.program.get_bytecode(
+                full_target=jac_file_path
             )
             if not codeobj:
                 raise ImportError(f"No bytecode found for {jac_file_path}")
@@ -379,9 +398,8 @@ class JacImporter(Importer):
                     spec.package_path,
                     spec.full_target,
                 )
-                codeobj = self.jac_machine.jac_program.get_bytecode(
-                    full_target=spec.full_target,
-                    full_compile=not self.jac_machine.interp_mode,
+                codeobj = self.jac_machine.program.get_bytecode(
+                    full_target=spec.full_target
                 )
 
                 # Since this is a compile time error, we can safely raise an exception here.