jaclang 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

jaclang/langserve/server.py

@@ -2,68 +2,37 @@
 
 from __future__ import annotations
 
-import threading
 from typing import Optional
 
+from jaclang.compiler.constant import (
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType,
+)
 from jaclang.langserve.engine import JacLangServer
 from jaclang.langserve.utils import debounce
 
 import lsprotocol.types as lspt
 
 server = JacLangServer()
-analysis_thread: Optional[threading.Thread] = None
-analysis_stop_event = threading.Event()
-
-
-def analyze_and_publish(ls: JacLangServer, uri: str, level: int = 2) -> None:
-    """Analyze and publish diagnostics."""
-    global analysis_thread, analysis_stop_event
-
-    def run_analysis() -> None:
-        ls.quick_check(uri)
-        ls.push_diagnostics(uri)
-        if not analysis_stop_event.is_set() and level > 0:
-            ls.deep_check(uri)
-            ls.push_diagnostics(uri)
-            if not analysis_stop_event.is_set() and level > 1:
-                ls.type_check(uri)
-                ls.push_diagnostics(uri)
-
-    analysis_thread = threading.Thread(target=run_analysis)
-    analysis_thread.start()
-
-
-def stop_analysis() -> None:
-    """Stop analysis."""
-    global analysis_thread, analysis_stop_event
-    if analysis_thread is not None:
-        analysis_stop_event.set()
-        analysis_thread.join()
-        analysis_stop_event.clear()
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
-async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
+    ls.analyze_and_publish(params.text_document.uri)
+    # token_params = lspt.SemanticTokensParams(
+    #     text_document=lspt.TextDocumentIdentifier(uri=params.text_document.uri)
+    # )
+    # tokens = semantic_tokens_full(ls, token_params)
+    # ls.send_notification("textDocument/publishSemanticTokens", tokens)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_CHANGE)
 @debounce(0.1)
-async def did_change(
-    ls: JacLangServer, params: lspt.DidChangeTextDocumentParams
-) -> None:
+async def did_change(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
-
-
-@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
-async def did_save(ls: JacLangServer, params: lspt.DidSaveTextDocumentParams) -> None:
-    """Check syntax on save."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
+    ls.analyze_and_publish(params.text_document.uri, level=0)
 
 
 @server.feature(
@@ -74,11 +43,8 @@ async def did_save(ls: JacLangServer, params: lspt.DidSaveTextDocumentParams) ->
         ]
     ),
 )
-async def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None:
+def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) -> None:
     """Check syntax on file creation."""
-    for file in params.files:
-        ls.quick_check(file.uri)
-        ls.push_diagnostics(file.uri)
 
 
 @server.feature(
@@ -89,13 +55,12 @@ async def did_create_files(ls: JacLangServer, params: lspt.CreateFilesParams) ->
         ]
     ),
 )
-async def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None:
+def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) -> None:
     """Check syntax on file rename."""
     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])
-        ls.quick_check(new_uris[i])
 
 
 @server.feature(
@@ -106,7 +71,7 @@ async def did_rename_files(ls: JacLangServer, params: lspt.RenameFilesParams) ->
         ]
     ),
 )
-async def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
+def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) -> None:
     """Check syntax on file delete."""
     for file in params.files:
         ls.delete_module(file.uri)
@@ -116,9 +81,7 @@ async def did_delete_files(ls: JacLangServer, params: lspt.DeleteFilesParams) ->
     lspt.TEXT_DOCUMENT_COMPLETION,
     lspt.CompletionOptions(trigger_characters=[".", ":", ""]),
 )
-async def completion(
-    ls: JacLangServer, params: lspt.CompletionParams
-) -> lspt.CompletionList:
+def completion(ls: JacLangServer, params: lspt.CompletionParams) -> lspt.CompletionList:
     """Provide completion."""
     return ls.get_completion(params.text_document.uri, params.position)
 
@@ -140,25 +103,35 @@ def hover(
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
-async def document_symbol(
+def document_symbol(
     ls: JacLangServer, params: lspt.DocumentSymbolParams
 ) -> list[lspt.DocumentSymbol]:
     """Provide document symbols."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri)
     return ls.get_document_symbols(params.text_document.uri)
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
-async def definition(
+def definition(
     ls: JacLangServer, params: lspt.TextDocumentPositionParams
 ) -> Optional[lspt.Location]:
     """Provide definition."""
-    stop_analysis()
-    analyze_and_publish(ls, params.text_document.uri, level=1)
     return ls.get_definition(params.text_document.uri, params.position)
 
 
+@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: JacLangServer, params: lspt.SemanticTokensParams
+) -> lspt.SemanticTokens:
+    """Provide semantic tokens."""
+    return ls.get_semantic_tokens(params.text_document.uri)
+
+
 def run_lang_server() -> None:
     """Run the language server."""
     server.start_io()

jaclang/langserve/tests/fixtures/base_module_structure.jac

@@ -0,0 +1,28 @@
+"""A Docstring can be added the head of any module.
+
+Any element in the module can also have a docstring.
+If there is only one docstring before the first element,
+it is assumed to be a module docstring.
+"""
+
+"""A docstring for add function"""
+can add(a: int, b: int) -> int {
+    return a + b;
+}
+# No docstring for subtract function
+
+can subtract(a: int, b: int) -> int {
+    return a - b;
+}
+
+with entry:__main__ {
+    print(add(1, subtract(3, 1)));
+}
+
+glob x: int = 10;
+
+enum Color {
+    RED,
+    GREEN,
+    BLUE
+}

jaclang/langserve/tests/fixtures/circle_pure.test.jac

@@ -0,0 +1,15 @@
+glob expected_area = 78.53981633974483;
+
+test a1 {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test a2 {
+    c = Circle(RAD);
+    check assertAlmostEqual(c.area(), expected_area);
+}
+
+test a3 {
+    c = Circle(RAD);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/langserve/tests/fixtures/import_include_statements.jac

@@ -0,0 +1,6 @@
+import:py os;
+import:py from math, sqrt as square_root;
+import:py datetime as dt;
+import:jac from base_module_structure, add as adsd, subtract,x,Color as clr;
+import:jac base_module_structure as base_module_structure;
+import:py from py_import,add1 as ss, sub1 as subtract1,apple,Orange1;

jaclang/langserve/tests/fixtures/py_import.py

@@ -0,0 +1,26 @@
+"""This is a helper file."""
+
+
+def add1():
+    return 1 + 1
+
+
+def sub1():
+    return 1 - 1
+
+
+# classes
+class Orange1:
+    def __init__(self):
+        self.orange = 1
+
+    def get_orange(self):
+        return self.orange
+
+    def set_orange(self, orange):
+        self.orange = orange
+
+
+# variables
+orange2 = 1
+apple = 1

jaclang/langserve/tests/test_server.py

@@ -63,10 +63,10 @@ class TestJacLangServer(TestCase):
         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(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(len(lsp.modules), 1)
         self.assertEqual(lsp.modules[circle_file].diagnostics[0].range.start.line, 22)
 
     def test_impl_stay_connected(self) -> None:
@@ -88,7 +88,7 @@ class TestJacLangServer(TestCase):
             "Circle class inherits from Shape.",
             lsp.get_hover_info(circle_file, pos).contents.value,
         )
-        lsp.type_check(circle_impl_file, force=True)
+        lsp.type_check(circle_impl_file)
         pos = lspt.Position(8, 11)
         self.assertIn(
             "ability) calculate_area: float",
@@ -105,9 +105,9 @@ class TestJacLangServer(TestCase):
         circle_impl_file = uris.from_fs_path(
             self.fixture_abs_path("circle_pure.impl.jac")
         )
-        lsp.quick_check(circle_impl_file, force=True)
-        lsp.deep_check(circle_impl_file, force=True)
-        lsp.type_check(circle_impl_file, force=True)
+        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",
@@ -180,3 +180,87 @@ class TestJacLangServer(TestCase):
             "guess_game4.jac:27:8-27:21",
             str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
         )
+
+    def test_test_annex(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_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",
+            lsp.get_hover_info(circle_file, pos).contents.value,
+        )
+
+    def test_go_to_defintion_import(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
+        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"),
+            (5, 65, "py_import.py:12:0-20:5"),
+            (5, 35, "py_import.py:3:0-4:5"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
+    def test_sem_tokens(self) -> None:
+        """Test that the Semantic Tokens are generated correctly."""
+        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)
+        sem_list = lsp.get_semantic_tokens(circle_file).data
+        expected_counts = [
+            ("<JacSemTokenType.VARIABLE: 8>, <JacSemTokenModifier.READONLY: 4>", 206),
+            (
+                "<JacSemTokenType.PROPERTY: 9>, <JacSemTokenModifier.DEFINITION: 2>,",
+                112,
+            ),
+            (
+                "<JacSemTokenType.PARAMETER: 7>, <JacSemTokenModifier.DECLARATION: 1>,",
+                56,
+            ),
+            (
+                "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
+                25,
+            ),
+            ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 12),
+            ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 37),
+            ("<JacSemTokenType.CLASS: 2>, <JacSemTokenModifier.DECLARATION: ", 162),
+            (
+                "<JacSemTokenType.NAMESPACE: 0>, <JacSemTokenModifier.DEFINITION: 2>,",
+                10,
+            ),
+            ("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)

jaclang/langserve/utils.py

@@ -2,12 +2,16 @@
 
 import asyncio
 import builtins
+import importlib.util
+import os
+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.symtable import Symbol, SymbolTable
+from jaclang.utils.helpers import import_target_to_relative_path
 
 import lsprotocol.types as lspt
 
@@ -68,7 +72,7 @@ def find_deepest_symbol_node_at_pos(
         if isinstance(node, ast.AstSymbolNode):
             last_symbol_node = node
 
-        for child in node.kid:
+        for child in [i for i in node.kid if i.loc.mod_path == node.loc.mod_path]:
             if position_within_node(child, line, character):
                 deeper_node = find_deepest_symbol_node_at_pos(child, line, character)
                 if deeper_node is not None:
@@ -150,7 +154,7 @@ def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
 
 def owner_sym(table: SymbolTable) -> Optional[Symbol]:
     """Get owner sym."""
-    if table.has_parent() and isinstance(table.owner, ast.AstSymbolNode):
+    if table.parent and isinstance(table.owner, ast.AstSymbolNode):
         return table.parent.lookup(table.owner.sym_name)
     return None
 
@@ -158,8 +162,14 @@ def owner_sym(table: SymbolTable) -> Optional[Symbol]:
 def create_range(loc: CodeLocInfo) -> lspt.Range:
     """Create an lspt.Range from a location object."""
     return lspt.Range(
-        start=lspt.Position(line=loc.first_line - 1, character=loc.col_start - 1),
-        end=lspt.Position(line=loc.last_line - 1, character=loc.col_end - 1),
+        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,
+        ),
     )
 
 
@@ -182,3 +192,103 @@ def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
             )
         )
     )
+
+
+def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None:
+    """Get path for a module import name."""
+    ret_target = None
+    module_location_path = mod_path.loc.mod_path
+    if mod_path.parent and (
+        (
+            isinstance(mod_path.parent.parent, ast.Import)
+            and mod_path.parent.parent.hint.tag.value == "py"
+        )
+        or (
+            isinstance(mod_path.parent, ast.Import)
+            and mod_path.parent.from_loc
+            and mod_path.parent.hint.tag.value == "py"
+        )
+    ):
+        if mod_path.path and name_node in mod_path.path:
+            temporary_path_str = ("." * mod_path.level) + ".".join(
+                [p.value for p in mod_path.path[: mod_path.path.index(name_node) + 1]]
+                if mod_path.path
+                else ""
+            )
+        else:
+            temporary_path_str = mod_path.path_str
+        sys.path.append(os.path.dirname(module_location_path))
+        spec = importlib.util.find_spec(temporary_path_str)
+        sys.path.remove(os.path.dirname(module_location_path))
+        if spec and spec.origin and spec.origin.endswith(".py"):
+            ret_target = spec.origin
+    elif mod_path.parent and (
+        (
+            isinstance(mod_path.parent.parent, ast.Import)
+            and mod_path.parent.parent.hint.tag.value == "jac"
+        )
+        or (
+            isinstance(mod_path.parent, ast.Import)
+            and mod_path.parent.from_loc
+            and mod_path.parent.hint.tag.value == "jac"
+        )
+    ):
+        ret_target = import_target_to_relative_path(
+            level=mod_path.level,
+            target=mod_path.path_str,
+            base_path=os.path.dirname(module_location_path),
+        )
+    return ret_target
+
+
+def get_item_path(mod_item: ast.ModuleItem) -> tuple[str, tuple[int, int]] | None:
+    """Get path."""
+    item_name = mod_item.name.value
+    if mod_item.from_parent.hint.tag.value == "py" and mod_item.from_parent.from_loc:
+        path = get_mod_path(mod_item.from_parent.from_loc, mod_item.name)
+        if path:
+            return get_definition_range(path, item_name)
+    elif mod_item.from_parent.hint.tag.value == "jac":
+        mod_node = mod_item.from_mod_path
+        if mod_node.sub_module and mod_node.sub_module._sym_tab:
+            for symbol_name, symbol in mod_node.sub_module._sym_tab.tab.items():
+                if symbol_name == item_name:
+                    return symbol.decl.loc.mod_path, (
+                        symbol.decl.loc.first_line - 1,
+                        symbol.decl.loc.last_line - 1,
+                    )
+    return None
+
+
+def get_definition_range(
+    filename: str, name: str
+) -> tuple[str, tuple[int, int]] | None:
+    """Get the start and end line of a function or class definition in a file."""
+    import ast
+
+    with open(filename, "r") as file:
+        source = file.read()
+
+    tree = ast.parse(source)
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.ClassDef)) and node.name == name:
+            start_line = node.lineno
+            end_line = (
+                node.body[-1].end_lineno
+                if hasattr(node.body[-1], "end_lineno")
+                else node.body[-1].lineno
+            )
+            if start_line and end_line:
+                return filename, (start_line - 1, end_line - 1)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == name:
+                    start_line = node.lineno
+                    end_line = (
+                        node.end_lineno if hasattr(node, "end_lineno") else node.lineno
+                    )
+                    if start_line and end_line:
+                        return filename, (start_line - 1, end_line - 1)
+
+    return None

jaclang/plugin/default.py

@@ -495,14 +495,14 @@ class JacFeatureDefaults:
     @hookimpl
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""
         conn_type = conn_type if conn_type else GenericEdge
 
         def builder() -> EdgeArchitype:
-            edge = conn_type()
+            edge = conn_type() if isinstance(conn_type, type) else conn_type
             edge._jac_.is_undirected = is_undirected
             if conn_assign:
                 for fld, val in zip(conn_assign[0], conn_assign[1]):

jaclang/plugin/feature.py

@@ -263,7 +263,7 @@ class JacFeature:
     @staticmethod
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""

jaclang/plugin/spec.py

@@ -246,7 +246,7 @@ class JacFeatureSpec:
     @hookspec(firstresult=True)
     def build_edge(
         is_undirected: bool,
-        conn_type: Optional[Type[EdgeArchitype]],
+        conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
         conn_assign: Optional[tuple[tuple, tuple]],
     ) -> Callable[[], EdgeArchitype]:
         """Jac's root getter."""

jaclang/tests/fixtures/aott_raise.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms.base, BaseLLM;
 
 obj model:BaseLLM: {
     can __infer__(meaning_in: str, **kwargs: dict) {

jaclang/tests/fixtures/edgetypeissue.jac

@@ -0,0 +1,10 @@
+node x {}
+
+edge e {
+    has name: str;
+}
+
+with entry {
+    nodes = root +:e(name="hello"):+> x();
+    print(nodes);
+}

jaclang/tests/fixtures/hello.jac

@@ -2,4 +2,4 @@
 
 with entry {
     "Hello World!" |> print;
-}
+}

jaclang/tests/fixtures/with_llm_function.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init {

jaclang/tests/fixtures/with_llm_lower.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init {

jaclang/tests/fixtures/with_llm_method.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init {

jaclang/tests/fixtures/with_llm_type.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 
 obj model:BaseLLM: {
     can init(output_str: str) {

jaclang/tests/fixtures/with_llm_vision.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, BaseLLM;
+import:py from mtllm.llms, BaseLLM;
 import:py from PIL, Image;
 import:py os;