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

jaclang/langserve/dev_server.jac

@@ -0,0 +1,201 @@
+"""Jaclang Language Server."""
+
+import from typing { Optional }
+
+import from jaclang.compiler.constant {
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType
+}
+
+import from dev_engine { JacLangServer }
+import from jaclang.settings { settings }
+
+import lsprotocol.types as lspt;
+
+
+with entry {
+    server = JacLangServer();
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
+async def did_open(ls: JacLangServerV2, params: lspt.DidOpenTextDocumentParams) -> None {
+    await ls.launch_deep_check(params.text_document.uri);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+async def did_save(ls: JacLangServerV2, params: lspt.DidOpenTextDocumentParams) -> None {
+    file_path = params.text_document.uri;
+    quick_check_passed = await ls.launch_quick_check(file_path);
+    if not quick_check_passed {
+        return;
+    }
+    await ls.launch_deep_check(file_path);
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+}
+
+
+"""Check syntax on change."""
+@server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
+async def did_change(
+    ls: JacLangServerV2,
+    params: lspt.DidChangeTextDocumentParams
+) -> None {
+    file_path = params.text_document.uri;
+    quick_check_passed = await ls.launch_quick_check(file_path);
+
+    if quick_check_passed {
+        document = ls.workspace.get_text_document(file_path);
+        lines = document.source.splitlines();
+        sem_manager = ls.sem_managers[file_path.removeprefix('file://')];
+        sem_manager.update_sem_tokens(
+            params,sem_manager.sem_tokens,lines
+        );
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+        await ls.launch_deep_check(file_path);
+        ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH);
+    }
+}
+
+
+"""Format the given document."""
+@server.feature(lspt.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: JacLangServerV2,
+    params: lspt.DocumentFormattingParams
+) -> list[lspt.TextEdit] {
+    return ls.formatted_jac(params.text_document.uri);
+}
+
+
+"""Check syntax on file creation."""
+@server.feature(
+    lspt.WORKSPACE_DID_CREATE_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[lspt.FileOperationFilter(pattern=lspt.FileOperationPattern('**/*.jac'))]
+    )
+)
+def did_create_files(ls: JacLangServerV2, params: lspt.CreateFilesParams) -> None {}
+
+
+"""Check syntax on file rename."""
+@server.feature(
+    lspt.WORKSPACE_DID_RENAME_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[lspt.FileOperationFilter(pattern=lspt.FileOperationPattern('**/*.jac'))]
+    )
+)
+def did_rename_files(ls: JacLangServerV2, params: lspt.RenameFilesParams) -> None {
+    new_uris = [ file.new_uri for file in params.files ];
+    old_uris = [ file.old_uri for file in params.files ];
+    for i in range(len(new_uris)) {
+        ls.rename_module(old_uris[i], new_uris[i]);
+    }
+}
+
+
+"""Check syntax on file delete."""
+@server.feature(
+    lspt.WORKSPACE_DID_DELETE_FILES,
+    lspt.FileOperationRegistrationOptions(
+        filters=[lspt.FileOperationFilter(pattern=lspt.FileOperationPattern('**/*.jac'))]
+    )
+)
+def did_delete_files(ls: JacLangServerV2, params: lspt.DeleteFilesParams) -> None {
+    for file in params.files {
+        ls.delete_module(file.uri);
+    }
+}
+
+
+"""Provide completion."""
+@server.feature(
+    lspt.TEXT_DOCUMENT_COMPLETION,
+    lspt.CompletionOptions(trigger_characters=['.', ':', 'a-zA-Z0-9'])
+)
+def completion(ls: JacLangServerV2, params: lspt.CompletionParams) -> lspt.CompletionList {
+    return ls.get_completion(
+        params.text_document.uri,
+        params.position,
+        params.context.trigger_character if params.context else None
+    );
+}
+
+
+"""Provide hover information for the given hover request."""
+@server.feature(lspt.TEXT_DOCUMENT_HOVER, lspt.HoverOptions(work_done_progress=True))
+def hover(
+    ls: JacLangServerV2,
+    params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Hover] {
+    return ls.get_hover_info(params.text_document.uri, params.position);
+}
+
+
+"""Provide document symbols."""
+@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+def document_symbol(
+    ls: JacLangServerV2,
+    params: lspt.DocumentSymbolParams
+) -> list[lspt.DocumentSymbol] {
+    return ls.get_outline(params.text_document.uri);
+}
+
+
+"""Provide definition."""
+@server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
+def definition(
+    ls: JacLangServerV2,
+    params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Location] {
+    return ls.get_definition(params.text_document.uri, params.position);
+}
+
+
+"""Provide references."""
+@server.feature(lspt.TEXT_DOCUMENT_REFERENCES)
+def references(ls: JacLangServerV2, params: lspt.ReferenceParams) -> list[lspt.Location] {
+    return ls.get_references(params.text_document.uri, params.position);
+}
+
+
+"""Rename symbol."""
+@server.feature(lspt.TEXT_DOCUMENT_RENAME)
+def rename(ls: JacLangServerV2, params: lspt.RenameParams) -> Optional[lspt.WorkspaceEdit] {
+    ls.log_warning('Auto Rename is Experimental, Please use with caution.');
+    return ls.rename_symbol(params.text_document.uri, params.position, params.new_name);
+}
+
+
+"""Provide semantic tokens."""
+@server.feature(
+    lspt.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    lspt.SemanticTokensLegend(
+        token_types=SemTokType.as_str_list(),
+        token_modifiers=SemTokMod.as_str_list()
+    )
+)
+def semantic_tokens_full(
+    ls: JacLangServerV2,
+    params: lspt.SemanticTokensParams
+) -> lspt.SemanticTokens {
+    return ls.get_semantic_tokens(params.text_document.uri);
+}
+
+
+"""Run the language server."""
+def run_lang_server() -> None {
+    settings.pass_timer = True;
+    server.start_io();
+}
+
+
+with entry {
+    if __name__ == '__main__' {
+        run_lang_server();
+    }
+}

jaclang/langserve/engine.jac

@@ -8,6 +8,7 @@ import from typing { Callable, Optional }
 
 import jaclang.compiler.unitree as uni;
 import from jaclang { JacMachineInterface as Jac }
+import from jaclang.compiler.constant {SymbolType}
 import from jaclang.compiler.program { JacProgram }
 import from jaclang.compiler.unitree { UniScopeNode }
 import from sem_manager { SemTokManager }
@@ -133,7 +134,7 @@ class JacLangServer(JacProgram , LanguageServer) {
             file_path_fs = file_path.removeprefix('file://');
             document = self.workspace.get_text_document(file_path);
             self._clear_alerts_for_file(file_path_fs);
-            build = self.build(use_str=document.source, file_path=document.path);
+            build = self.build(use_str=document.source, file_path=document.path,type_check=True);
             self.update_modules(file_path_fs, build);
             if build.annexable_by {
                 return self.deep_check(
@@ -259,7 +260,7 @@ class JacLangServer(JacProgram , LanguageServer) {
                         }
                         symb = temp_tab.lookup(symbol);
                         if symb {
-                            fetc_tab = symb.fetch_sym_tab;
+                            fetc_tab = symb.symbol_table;
                             if fetc_tab {
                                 temp_tab = fetc_tab;
                             } else {
@@ -284,9 +285,9 @@ class JacLangServer(JacProgram , LanguageServer) {
                             }
                         }
                         for base_class_symbol in base {
-                            if base_class_symbol.fetch_sym_tab {
+                            if base_class_symbol.symbol_table {
                                 completion_items += utils.collect_all_symbols_in_scope(
-                                    base_class_symbol.fetch_sym_tab,
+                                    base_class_symbol.symbol_table,
                                     up_tree=False
                                 );
                             }
@@ -446,7 +447,25 @@ class JacLangServer(JacProgram , LanguageServer) {
         }
         node_selected = sem_mgr.static_sem_tokens[token_index][3];
         if node_selected {
-            if isinstance(node_selected, uni.Name)
+            if (node_selected.sym.sym_type == SymbolType.MODULE) {
+                spec = node_selected.sym.decl.parent.resolve_relative_path();
+                if spec {
+                    spec = spec[ 5 : ] if spec.startswith('File:') else spec;
+                    return lspt.Location(
+                        uri=uris.from_fs_path(spec),
+                        range=lspt.Range(
+                            start=lspt.Position(line=0, character=0),
+                            end=lspt.Position(line=0, character=0)
+                        )
+                    );
+                } else {
+                    return None;
+                }
+            }
+            if isinstance(node_selected.sym, uni.NameAtom) {
+                node_selected = node_selected.name_of;
+            }
+            elif isinstance(node_selected, uni.Name)
             and node_selected.parent
             and isinstance(node_selected.parent, uni.ModulePath)
              {

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -190,7 +190,7 @@ class TestLangServe:
         await did_save(ls, params)
         sem_tokens = ls.get_semantic_tokens(uri)
         # semantic tokens should still be present even if there is a syntax error
-        assert len(sem_tokens.data) == 300
+        assert len(sem_tokens.data) == 320
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -254,7 +254,7 @@ class TestLangServe:
         await did_change(ls, params)
         sem_tokens = ls.get_semantic_tokens(uri)
         # semantic tokens should still be present even if there is a syntax error
-        assert len(sem_tokens.data) == 300
+        assert len(sem_tokens.data) == 320
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1

jaclang/langserve/tests/test_dev_server.py

@@ -0,0 +1,80 @@
+from jaclang.utils.test import TestCase
+from jaclang.vendor.pygls import uris
+from jaclang.vendor.pygls.workspace import Workspace
+
+import lsprotocol.types as lspt
+from jaclang.langserve.dev_engine import JacLangServer
+
+
+class TestJacLangServer(TestCase):
+
+    def test_type_annotation_assignment_server(self) -> None:
+        """Test that the server doesn't run if there is a syntax error."""
+        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(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/type_annotation_assignment.jac"
+            )
+        )
+        lsp.deep_check(circle_file)
+        self.assertIn(
+            "(public variable) should_fail1: int",
+            lsp.get_hover_info(circle_file, lspt.Position(1, 15)).contents.value,
+        )
+        self.assertIn(
+            "(public variable) should_pass2: str",
+            lsp.get_hover_info(circle_file, lspt.Position(2, 15)).contents.value,
+        )
+        self.assertIn(
+            "(public variable) should_fail2: str",
+            lsp.get_hover_info(circle_file, lspt.Position(3, 15)).contents.value,
+        )
+        diagnostics_list = list(lsp.diagnostics.values())[0]
+        self.assertEqual(len(diagnostics_list), 2)
+        self.assertIn(
+            "Cannot assign",
+            diagnostics_list[0].message,
+        )
+        self.assertEqual(
+            "1:5-1:30",
+            str(diagnostics_list[0].range),
+        )
+        self.assertEqual(
+            "3:5-3:27",
+            str(diagnostics_list[1].range),
+        )
+
+
+    def test_member_access_type_inferred_server(self) -> None:
+        """Test that the server doesn't run if there is a syntax error."""
+        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(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/member_access_type_inferred.jac"
+            )
+        )
+        lsp.deep_check(circle_file)
+        self.assertIn(
+            "(public variable) i: int",
+            lsp.get_hover_info(circle_file, lspt.Position(10, 2)).contents.value,
+        )
+        self.assertIn(
+            "(public variable) s: str",
+            lsp.get_hover_info(circle_file, lspt.Position(11, 2)).contents.value,
+        )
+        diagnostics_list = list(lsp.diagnostics.values())[0]
+        self.assertEqual(len(diagnostics_list), 1)
+        self.assertIn(
+            "Cannot assign",
+            diagnostics_list[0].message,
+        )
+        self.assertEqual(
+            "11:2-11:12",
+            str(diagnostics_list[0].range),
+        )

jaclang/langserve/tests/test_server.py

@@ -588,3 +588,16 @@ class TestJacLangServer(TestCase):
             )
             for expected in expected_refs:
                 self.assertIn(expected, references)
+
+    def test_binder_go_to_module(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
+        guess_game_file = uris.from_fs_path(self.fixture_abs_path('../../../compiler/passes/main/tests/fixtures/sym_binder.jac'))
+        lsp.deep_check(guess_game_file)
+        self.assertIn(
+            "/tests/fixtures/M1.jac:0:0-0:0",
+            str(lsp.get_definition(guess_game_file, lspt.Position(29, 9))),
+        )

jaclang/runtimelib/builtin.py

@@ -7,8 +7,9 @@ from abc import abstractmethod
 from enum import Enum
 from typing import ClassVar, Optional, override
 
-from jaclang.runtimelib.constructs import Archetype, NodeArchetype, Root
+from jaclang.runtimelib.constructs import NodeArchetype
 from jaclang.runtimelib.machine import JacMachineInterface as Jac
+from jaclang.runtimelib.utils import collect_node_connections
 
 
 class AccessLevelEnum(Enum):
@@ -58,53 +59,39 @@ def printgraph(
     )
 
 
-def jid(obj: Archetype) -> str:
-    """Get the id of the object."""
-    return Jac.object_ref(obj)
-
-
-def jobj(id: str) -> Archetype | None:
-    """Get the object from the id."""
-    return Jac.get_object(id)
-
-
-def grant(obj: Archetype, level: AccessLevelEnum) -> None:
-    """Grant permission for the object."""
-    assert isinstance(level, AccessLevelEnum), f'Use {ConnectPerm} instead of "CONNECT"'
-    Jac.perm_grant(obj, level=level.value)
-
-
-def revoke(obj: Archetype) -> None:
-    """Revoke permission for the object."""
-    Jac.perm_revoke(obj)
-
-
-def allroots() -> list[Jac.Root]:
-    """Get all the roots."""
-    return Jac.get_all_root()
+jid = Jac.object_ref
+jobj = Jac.get_object
+grant = Jac.perm_grant
+revoke = Jac.perm_revoke
+allroots = Jac.get_all_root
+save = Jac.save
+commit = Jac.commit
 
 
 def _jac_graph_json(file: Optional[str] = None) -> str:
     """Get the graph in json string."""
-    processed: list[Root | NodeArchetype] = []
+    visited_nodes: set = set()
+    connections: set = set()
+    edge_ids: set = set()
     nodes: list[dict] = []
     edges: list[dict] = []
-    working_set: list[tuple] = []
-
     root = Jac.root()
+
+    collect_node_connections(root, visited_nodes, connections, edge_ids)
+
+    # Create nodes list from visited nodes
     nodes.append({"id": id(root), "label": "root"})
+    for node_arch in visited_nodes:
+        if node_arch != root:
+            nodes.append({"id": id(node_arch), "label": repr(node_arch)})
+
+    # Create edges list with labels from connections
+    for _, source_node, target_node, edge_arch in connections:
+        edge_data = {"from": str(id(source_node)), "to": str(id(target_node))}
+        if repr(edge_arch) != "GenericEdge()":
+            edge_data["label"] = repr(edge_arch)
+        edges.append(edge_data)
 
-    processed.append(root)
-    working_set = [(root, ref) for ref in Jac.refs(root)]
-
-    while working_set:
-        start, end = working_set.pop(0)
-        edges.append({"from": id(start), "to": id(end)})
-        nodes.append({"id": id(end), "label": repr(end)})
-        processed.append(end)
-        for ref in Jac.refs(end):
-            if ref not in processed:
-                working_set.append((end, ref))
     output = json.dumps(
         {
             "version": "1.0",
@@ -128,6 +115,8 @@ __all__ = [
     "grant",
     "revoke",
     "allroots",
+    "save",
+    "commit",
     "NoPerm",
     "ReadPerm",
     "ConnectPerm",

jaclang/runtimelib/importer.py

@@ -2,10 +2,7 @@
 
 from __future__ import annotations
 
-import importlib
-import importlib.util
 import os
-import sys
 import types
 from os import getcwd, path
 from typing import Optional, Union
@@ -146,69 +143,43 @@ class Importer:
 
 
 class PythonImporter(Importer):
-    """Importer for Python modules."""
+    """Importer for Python modules using Jac AST conversion."""
+
+    def __init__(self) -> None:
+        """Initialize the Python importer."""
+        super().__init__()
+        from jaclang.utils.module_resolver import PythonModuleResolver
+
+        self.resolver = PythonModuleResolver()
+
+    def load_and_execute(self, file_path: str) -> types.ModuleType:
+        """Convert Python file to Jac AST and create module."""
+        module_name = os.path.splitext(os.path.basename(file_path))[0]
+        module = types.ModuleType(module_name)
+        module.__file__ = file_path
+        module.__name__ = "__main__"
+
+        from jaclang.runtimelib.machine import JacMachine
+
+        codeobj = JacMachine.program.get_bytecode(full_target=file_path)
+        if codeobj:
+            exec(codeobj, module.__dict__)
+        else:
+            raise ImportError(f"Failed to generate bytecode for {file_path}")
+
+        return module
 
     def run_import(self, spec: ImportPathSpec) -> ImportReturn:
-        """Run the import process for Python modules."""
+        """Run the import process for Python modules using Jac AST."""
         try:
-            loaded_items: list = []
-            if spec.target.startswith("."):
-                spec.target = spec.target.lstrip(".")
-                if len(spec.target.split(".")) > 1:
-                    spec.target = spec.target.split(".")[-1]
-                full_target = path.normpath(path.join(spec.caller_dir, spec.target))
-                imp_spec = importlib.util.spec_from_file_location(
-                    spec.target, full_target + ".py"
-                )
-                if imp_spec and imp_spec.loader:
-                    imported_module = importlib.util.module_from_spec(imp_spec)
-                    sys.modules[imp_spec.name] = imported_module
-                    imp_spec.loader.exec_module(imported_module)
-                else:
-                    raise ImportError(
-                        f"Cannot find module {spec.target} at {full_target}"
-                    )
-            else:
-                imported_module = importlib.import_module(name=spec.target)
-
-            main_module = __import__("__main__")
-            if spec.absorb:
-                for name in dir(imported_module):
-                    if not name.startswith("_"):
-                        setattr(main_module, name, getattr(imported_module, name))
-
-            elif spec.items:
-                for name, alias in spec.items.items():
-                    if isinstance(alias, bool):
-                        alias = name
-                    try:
-                        item = getattr(imported_module, name)
-                        if item not in loaded_items:
-                            setattr(
-                                main_module,
-                                alias if isinstance(alias, str) else name,
-                                item,
-                            )
-                            loaded_items.append(item)
-                    except AttributeError as e:
-                        if hasattr(imported_module, "__path__"):
-                            item = importlib.import_module(f"{spec.target}.{name}")
-                            if item not in loaded_items:
-                                setattr(
-                                    main_module,
-                                    alias if isinstance(alias, str) else name,
-                                    item,
-                                )
-                                loaded_items.append(item)
-                        else:
-                            raise e
+            python_file_path = self.resolver.resolve_module_path(
+                target=spec.target,
+                base_path=spec.base_path,
+            )
+            imported_module = self.load_and_execute(python_file_path)
+            # JacMachineInterface.load_module(imported_module.__name__, imported_module)
 
-            else:
-                setattr(
-                    __import__("__main__"),
-                    spec.mdl_alias if isinstance(spec.mdl_alias, str) else spec.target,
-                    imported_module,
-                )
+            loaded_items: list = []
             self.result = ImportReturn(imported_module, loaded_items, self)
             return self.result
 
@@ -351,7 +322,7 @@ class JacImporter(Importer):
             if os.path.isdir(spec.full_target):
                 module = self.handle_directory(spec.module_name, spec.full_target)
             else:
-                spec.full_target += ".jac" if spec.language == "jac" else ".py"
+                spec.full_target += ".jac" if spec.language in ["jac", "jir"] else ".py"
                 module = self.create_jac_py_module(
                     module_name,
                     spec.package_path,