jaclang 0.7.1__py3-none-any.whl → 0.7.7__py3-none-any.whl

jaclang/langserve/server.py

@@ -2,66 +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) -> None:
-    """Analyze and publish diagnostics."""
-    global analysis_thread, analysis_stop_event
-
-    def run_analysis() -> None:
-        ls.quick_check(uri)
-        ls.push_diagnostics(uri)
-        ls.deep_check(uri)
-        ls.push_diagnostics(uri)
-        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(
@@ -72,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(
@@ -87,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(
@@ -104,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)
@@ -114,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)
 
@@ -137,6 +102,36 @@ def hover(
     return ls.get_hover_info(params.text_document.uri, params.position)
 
 
+@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+def document_symbol(
+    ls: JacLangServer, params: lspt.DocumentSymbolParams
+) -> list[lspt.DocumentSymbol]:
+    """Provide document symbols."""
+    return ls.get_document_symbols(params.text_document.uri)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DEFINITION)
+def definition(
+    ls: JacLangServer, params: lspt.TextDocumentPositionParams
+) -> Optional[lspt.Location]:
+    """Provide definition."""
+    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.jac

@@ -18,9 +18,9 @@ Below we have the demonstration of a class to calculate the area of a circle.
 *#
 
 """Enum for shape types"""
-enum ShapeType  {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+enum ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Base class for a shape."""
@@ -50,24 +50,28 @@ with entry {
 # Global also works here
 
 with entry:__main__ {
-# To run the program functionality
-print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    # To run the program functionality
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }
 # Unit Tests!
 
 glob expected_area = 78.53981633974483;
 
-test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+test calc_area {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
-test circle_area   {
+test circle_area {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
-test circle_type   {
+test circle_type {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/langserve/tests/fixtures/circle_err.jac

@@ -59,15 +59,15 @@ print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}
 glob expected_area = 78.53981633974483;
 
 test calc_area   {
-    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
 test circle_area   {
     c = Circle(RAD);
-    check.assertAlmostEqual(c.area(), expected_area);
+    check assertAlmostEqual(c.area(), expected_area);
 }
 
 test circle_type   {
     c = Circle(RAD);
-    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

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

@@ -1,8 +1,8 @@
 """Enum for shape types"""
 
 :enum:ShapeType {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Function to calculate the area of a circle."""
@@ -23,6 +23,10 @@
 }
 
 :can:main_run {
-    print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-    print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }

jaclang/langserve/tests/fixtures/circle_pure.jac

@@ -11,7 +11,7 @@ can calculate_area(radius: float) -> float;
 can main_run;
 
 """Base class for a shape."""
-obj Shape {
+obj : priv Shape {
     has shape_type: ShapeType;
 
     can area -> float abs;
@@ -22,7 +22,7 @@ obj Circle :Shape: {
     has radius: float;
 
     can init(radius: float);
-    can area -> float;
+    override can area -> float;
 }
 # Radius of the demo circle
 

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

@@ -4,6 +4,8 @@ from jaclang.vendor.pygls.workspace import Workspace
 from jaclang.langserve.engine import JacLangServer
 from .session import LspSession
 
+import lsprotocol.types as lspt
+
 
 class TestJacLangServer(TestCase):
 
@@ -61,8 +63,204 @@ 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:
+        """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.jac"))
+        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)
+        pos = lspt.Position(8, 11)
+        self.assertIn(
+            "ability) calculate_area: float",
+            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+        )
+
+    def test_impl_auto_discover(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_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",
+            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+        )
+
+    def test_show_type_impl(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
+        target = uris.from_fs_path(
+            self.fixture_abs_path("../../../../examples/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",
+            lsp.get_hover_info(target, pos).contents.value,
+        )
+
+    def test_outline_symbols(self) -> None:
+        """Test that the outline symbols are 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_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:
+        """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
+        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))),
+        )
+        self.assertIn(
+            "fixtures/circle_pure.jac:13:11-13:16",
+            str(lsp.get_definition(circle_file, lspt.Position(20, 17))),
+        )
+
+    def test_go_to_definition_method(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("../../../../examples/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_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)