jaclang 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

jaclang/langserve/tests/fixtures/circle.jac

@@ -0,0 +1,73 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+# Module-level global var
+
+glob RAD = 5;
+
+"""Function to calculate the area of a circle."""
+can calculate_area(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+#* (This is multiline comments in Jac)
+Above we have the demonstration of a function to calculate the area of a circle.
+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"
+}
+
+"""Base class for a shape."""
+obj Shape {
+    has shape_type: ShapeType;
+
+    """Abstract method to calculate the area of a shape."""
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    can init(radius: float) {
+        super.init(ShapeType.CIRCLE);
+        self.radius = radius;
+    }
+
+    """Overridden method to calculate the area of the circle."""
+    override can area -> float {
+        return math.pi * self.radius * self.radius;
+    }
+}
+
+with entry {
+    c = Circle(RAD);
+}
+# 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()}");
+}
+# Unit Tests!
+
+glob expected_area = 78.53981633974483;
+
+test calc_area   {
+    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test circle_area   {
+    c = Circle(RAD);
+    check.assertAlmostEqual(c.area(), expected_area);
+}
+
+test circle_type   {
+    c = Circle(RAD);
+    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/langserve/tests/fixtures/circle_err.jac

@@ -0,0 +1,73 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+# Module-level global var
+
+glob RAD = 5;
+
+"""Function to calculate the area of a circle."""
+can calculate_area(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+#* (This is multiline comments in Jac)
+Above we have the demonstration of a function to calculate the area of a circle.
+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"
+}
+
+"""Base class for a shape."""
+obj Shape {
+    has shape_type: ShapeType;
+
+    """Abstract method to calculate the area of a shape."""
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    can init(radius: float) {
+        super.init(ShapeType.CIRCLE);
+        self.radius = radius;
+    }
+
+    """Overridden method to calculate the area of the circle."""
+    override can area -> float {
+        return math.pi * self.radius * self.radius;
+    }
+}
+
+with entry {
+    c = Circle(RAD);
+}
+# 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()}");
+}
+# Unit Tests!
+
+glob expected_area = 78.53981633974483;
+
+test calc_area   {
+    check.assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test circle_area   {
+    c = Circle(RAD);
+    check.assertAlmostEqual(c.area(), expected_area);
+}
+
+test circle_type   {
+    c = Circle(RAD);
+    check.assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

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

@@ -0,0 +1,32 @@
+"""Enum for shape types"""
+
+:enum:ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
+}
+
+"""Function to calculate the area of a circle."""
+:can:calculate_area
+(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+
+:obj:Circle:can:init
+(radius: float) {
+    self.radius = radius;
+    super.init(ShapeType.CIRCLE);
+}
+
+"""Overridden method to calculate the area of the circle."""
+:obj:Circle:can:area -> float {
+    return math.pi * self.radius * self.radius;
+}
+
+: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()}"
+    );
+}

jaclang/langserve/tests/fixtures/circle_pure.jac

@@ -0,0 +1,34 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+
+enum ShapeType;
+
+can calculate_area(radius: float) -> float;
+can main_run;
+
+"""Base class for a shape."""
+obj : priv Shape {
+    has shape_type: ShapeType;
+
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    has radius: float;
+
+    can init(radius: float);
+    override can area -> float;
+}
+# Radius of the demo circle
+
+glob RAD = 5, c = Circle(radius=RAD);
+
+"""Here we run the main program."""
+with entry:__main__ {
+    main_run();
+}

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

@@ -0,0 +1,32 @@
+"""Enum for shape types"""
+
+:enum:ShapeType {
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
+}
+
+"""Function to calculate the area of a circle."""
+:can:calculate_area
+(radius: float) -> float {
+    return math.pi * radius * radius;
+}
+
+:obj:Circle:can:init
+(radius: float) {
+    self.radius = radius;
+    super.init(ShapeType.CIRCLE);
+}
+
+"""Overridden method to calculate the area of the circle."""
+:obj:Circle:can:area -> float {
+    return math.pi * self.radius * self.radius;
+}
+
+: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()}"
+    );
+}

jaclang/langserve/tests/fixtures/circle_pure_err.jac

@@ -0,0 +1,34 @@
+"""
+This module demonstrates a simple circle class and a function to calculate
+the area of a circle in all of Jac's glory.
+"""
+
+import:py math;
+
+enum ShapeType;
+
+can calculate_area(radius: float) -> float;
+can main_run;
+
+"""Base class for a shape."""
+obj Shape {
+    has shape_type: ShapeType;
+
+    can area -> float abs;
+}
+
+"""Circle class inherits from Shape."""
+obj Circle :Shape: {
+    has radius: float;
+
+    can init(radius: float);
+    can area -> float;
+}
+# Radius of the demo circle
+
+glob RAD = 5, c = Circle(radius=RAD);
+
+"""Here we run the main program."""
+with entry:__main__ {
+    main_run();
+}

jaclang/langserve/tests/test_server.py

@@ -1,7 +1,11 @@
 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
+
 
 class TestJacLangServer(TestCase):
 
@@ -28,9 +32,160 @@ class TestJacLangServer(TestCase):
                     {
                         "range": {
                             "start": {"line": 0, "character": 0},
-                            "end": {"line": 4, "character": 0},
+                            "end": {"line": 2, "character": 0},
                         },
                         "newText": 'with entry {\n    print("Hello, World!");\n}\n',
                     }
                 ],
             )
+
+    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()
+        # 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, force=True)
+        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, force=True)
+        lsp.deep_check(circle_impl_file, force=True)
+        lsp.type_check(circle_impl_file, force=True)
+        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)
+        expected_string = (
+            "DocumentSymbol(name='calculate_area', kind=<SymbolKind.Function: 12>, range=9:0-9:43, "
+            "selection_range=9:0-9:43, detail=None, tags=None, deprecated=None, children=["
+            "DocumentSymbol(name='radius', kind=<SymbolKind.Variable: 13>, range=9:1-9:14, "
+            "selection_range=9:1-9:14, detail=None, tags=None, deprecated=None, children=[])])"
+        )
+        self.assertEqual(
+            expected_string, str((lsp.get_document_symbols(circle_file))[6])
+        )
+        self.assertEqual(10, 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:12:0-17:1",
+            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:4-27:34",
+            str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
+        )

jaclang/langserve/utils.py

@@ -1,12 +1,15 @@
 """Utility functions for the language server."""
 
 import asyncio
+import builtins
 from functools import wraps
-from typing import Any, Awaitable, Callable, Coroutine, ParamSpec, TypeVar
+from typing import Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.symtable import SymbolTable
+from jaclang.compiler.codeloc import CodeLocInfo
+from jaclang.compiler.symtable import Symbol, SymbolTable
 
+import lsprotocol.types as lspt
 
 T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
 P = ParamSpec("P")
@@ -53,3 +56,125 @@ def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]:
     for i in sym_tab.kid:
         sym_tabs += sym_tab_list(i, file_path=file_path)
     return sym_tabs
+
+
+def find_deepest_symbol_node_at_pos(
+    node: ast.AstNode, line: int, character: int
+) -> Optional[ast.AstSymbolNode]:
+    """Return the deepest symbol node that contains the given position."""
+    last_symbol_node = None
+
+    if position_within_node(node, line, character):
+        if isinstance(node, ast.AstSymbolNode):
+            last_symbol_node = node
+
+        for child in node.kid:
+            if position_within_node(child, line, character):
+                deeper_node = find_deepest_symbol_node_at_pos(child, line, character)
+                if deeper_node is not None:
+                    last_symbol_node = deeper_node
+
+    return last_symbol_node
+
+
+def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
+    """Check if the position falls within the node's location."""
+    if node.loc.first_line < line + 1 < node.loc.last_line:
+        return True
+    if (
+        node.loc.first_line == line + 1
+        and node.loc.col_start <= character + 1
+        and (
+            node.loc.last_line == line + 1
+            and node.loc.col_end >= character + 1
+            or node.loc.last_line > line + 1
+        )
+    ):
+        return True
+    if (
+        node.loc.last_line == line + 1
+        and node.loc.col_start <= character + 1 <= node.loc.col_end
+    ):
+        return True
+    return False
+
+
+def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
+    """Recursively collect symbols from the AST."""
+    symbols = []
+    if node is None:
+        return symbols
+
+    for key, item in node.tab.items():
+        if key in dir(builtins):
+            continue
+        if item in [owner_sym(tab) for tab in node.kid]:
+            continue
+        else:
+
+            pos = create_range(item.defn[0].loc)
+            symbol = lspt.DocumentSymbol(
+                name=key,
+                kind=kind_map(item.defn[0]),
+                range=pos,
+                selection_range=pos,
+                children=[],
+            )
+            symbols.append(symbol)
+
+    for sub_tab in node.kid:
+        sub_symbols = collect_symbols(sub_tab)
+
+        if isinstance(
+            sub_tab.owner,
+            (ast.IfStmt, ast.ElseStmt, ast.WhileStmt, ast.IterForStmt, ast.InForStmt),
+        ):
+            symbols.extend(sub_symbols)
+        else:
+            sub_pos = create_range(sub_tab.owner.loc)
+            symbol = lspt.DocumentSymbol(
+                name=sub_tab.name,
+                kind=kind_map(sub_tab.owner),
+                range=sub_pos,
+                selection_range=sub_pos,
+                children=sub_symbols,
+            )
+            symbols.append(symbol)
+
+    return symbols
+
+
+def owner_sym(table: SymbolTable) -> Optional[Symbol]:
+    """Get owner sym."""
+    if table.has_parent() and isinstance(table.owner, ast.AstSymbolNode):
+        return table.parent.lookup(table.owner.sym_name)
+    return None
+
+
+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),
+    )
+
+
+def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind:
+    """Map the symbol node to an lspt.SymbolKind."""
+    return (
+        lspt.SymbolKind.Function
+        if isinstance(sub_tab, (ast.Ability, ast.AbilityDef))
+        else (
+            lspt.SymbolKind.Class
+            if isinstance(sub_tab, (ast.Architype, ast.ArchDef))
+            else (
+                lspt.SymbolKind.Module
+                if isinstance(sub_tab, ast.Module)
+                else (
+                    lspt.SymbolKind.Enum
+                    if isinstance(sub_tab, (ast.Enum, ast.EnumDef))
+                    else lspt.SymbolKind.Variable
+                )
+            )
+        )
+    )