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

jaclang/langserve/engine.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+import logging
 from enum import IntEnum
 from hashlib import md5
-from typing import Optional, Sequence
+from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
@@ -14,7 +15,11 @@ from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main.schedules import type_checker_sched
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
 from jaclang.compiler.passes.transform import Alert
-from jaclang.langserve.utils import find_deepest_node_at_pos
+from jaclang.langserve.utils import (
+    collect_symbols,
+    create_range,
+    find_deepest_symbol_node_at_pos,
+)
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
 
@@ -35,8 +40,8 @@ class ModuleInfo:
     def __init__(
         self,
         ir: ast.Module,
-        errors: Sequence[Alert],
-        warnings: Sequence[Alert],
+        errors: list[Alert],
+        warnings: list[Alert],
         alev: ALev,
         parent: Optional[ModuleInfo] = None,
     ) -> None:
@@ -58,35 +63,26 @@ class ModuleInfo:
         """Return if there are syntax errors."""
         return len(self.errors) > 0 and self.alev == ALev.QUICK
 
+    def update_with(self, new_info: ModuleInfo) -> None:
+        """Update module info."""
+        self.ir = new_info.ir
+        self.errors += [i for i in new_info.errors if i not in self.errors]
+        self.warnings += [i for i in new_info.warnings if i not in self.warnings]
+        self.alev = new_info.alev
+        self.diagnostics = self.gen_diagnostics()
+
     def gen_diagnostics(self) -> list[lspt.Diagnostic]:
         """Return diagnostics."""
         return [
             lspt.Diagnostic(
-                range=lspt.Range(
-                    start=lspt.Position(
-                        line=error.loc.first_line - 1, character=error.loc.col_start - 1
-                    ),
-                    end=lspt.Position(
-                        line=error.loc.last_line - 1,
-                        character=error.loc.col_end - 1,
-                    ),
-                ),
+                range=create_range(error.loc),
                 message=error.msg,
                 severity=lspt.DiagnosticSeverity.Error,
             )
             for error in self.errors
         ] + [
             lspt.Diagnostic(
-                range=lspt.Range(
-                    start=lspt.Position(
-                        line=warning.loc.first_line - 1,
-                        character=warning.loc.col_start - 1,
-                    ),
-                    end=lspt.Position(
-                        line=warning.loc.last_line - 1,
-                        character=warning.loc.col_end - 1,
-                    ),
-                ),
+                range=create_range(warning.loc),
                 message=warning.msg,
                 severity=lspt.DiagnosticSeverity.Warning,
             )
@@ -104,7 +100,7 @@ class JacLangServer(LanguageServer):
 
     def module_not_diff(self, uri: str, alev: ALev) -> bool:
         """Check if module was changed."""
-        doc = self.workspace.get_document(uri)
+        doc = self.workspace.get_text_document(uri)
         return (
             doc.uri in self.modules
             and self.modules[doc.uri].ir.source.hash
@@ -125,17 +121,25 @@ class JacLangServer(LanguageServer):
 
     def unwind_to_parent(self, file_path: str) -> str:
         """Unwind to parent."""
+        orig_file_path = file_path
         if file_path in self.modules:
             while cur := self.modules[file_path].parent:
                 file_path = cur.uri
+            if file_path == orig_file_path and (
+                discover := self.modules[file_path].ir.annexable_by
+            ):
+                file_path = uris.from_fs_path(discover)
+                self.quick_check(file_path)
         return file_path
 
-    def update_modules(self, file_path: str, build: Pass, alev: ALev) -> None:
+    def update_modules(
+        self, file_path: str, build: Pass, alev: ALev, refresh: bool = False
+    ) -> None:
         """Update modules."""
         if not isinstance(build.ir, ast.Module):
             self.log_error("Error with module build.")
             return
-        self.modules[file_path] = ModuleInfo(
+        new_mod = ModuleInfo(
             ir=build.ir,
             errors=[
                 i
@@ -149,33 +153,44 @@ class JacLangServer(LanguageServer):
             ],
             alev=alev,
         )
+        if not refresh and file_path in self.modules:
+            self.modules[file_path].update_with(new_mod)
+        else:
+            self.modules[file_path] = new_mod
         for p in build.ir.mod_deps.keys():
             uri = uris.from_fs_path(p)
-            self.modules[uri] = ModuleInfo(
+            new_mod = ModuleInfo(
                 ir=build.ir.mod_deps[p],
                 errors=[i for i in build.errors_had if i.loc.mod_path == p],
                 warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
                 alev=alev,
             )
+            if not refresh and uri in self.modules:
+                self.modules[uri].update_with(new_mod)
+            else:
+                self.modules[uri] = new_mod
+            self.modules[uri].parent = (
+                self.modules[file_path] if file_path != uri else None
+            )
 
-    def quick_check(self, file_path: str) -> None:
+    def quick_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file."""
-        if self.module_not_diff(file_path, ALev.QUICK):
+        if not force and self.module_not_diff(file_path, ALev.QUICK):
             return
         try:
-            document = self.workspace.get_document(file_path)
+            document = self.workspace.get_text_document(file_path)
             build = jac_str_to_pass(
                 jac_str=document.source, file_path=document.path, schedule=[]
             )
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
-        self.update_modules(file_path, build, ALev.QUICK)
+        self.update_modules(file_path, build, ALev.QUICK, refresh=True)
 
-    def deep_check(self, file_path: str) -> None:
+    def deep_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file and its dependencies."""
         if file_path in self.modules:
-            self.quick_check(file_path)
-        if self.module_not_diff(file_path, ALev.DEEP):
+            self.quick_check(file_path, force=force)
+        if not force and self.module_not_diff(file_path, ALev.DEEP):
             return
         try:
             file_path = self.unwind_to_parent(file_path)
@@ -184,11 +199,11 @@ class JacLangServer(LanguageServer):
             self.log_error(f"Error during syntax check: {e}")
         self.update_modules(file_path, build, ALev.DEEP)
 
-    def type_check(self, file_path: str) -> None:
+    def type_check(self, file_path: str, force: bool = False) -> None:
         """Rebuild a file and its dependencies."""
         if file_path not in self.modules:
-            self.deep_check(file_path)
-        if self.module_not_diff(file_path, ALev.TYPE):
+            self.deep_check(file_path, force=force)
+        if not force and self.module_not_diff(file_path, ALev.TYPE):
             return
         try:
             file_path = self.unwind_to_parent(file_path)
@@ -204,7 +219,7 @@ class JacLangServer(LanguageServer):
     ) -> lspt.CompletionList:
         """Return completion for a file."""
         items = []
-        document = self.workspace.get_document(file_path)
+        document = self.workspace.get_text_document(file_path)
         current_line = document.lines[position.line].strip()
         if current_line.endswith("hello."):
 
@@ -228,7 +243,7 @@ class JacLangServer(LanguageServer):
     def formatted_jac(self, file_path: str) -> list[lspt.TextEdit]:
         """Return formatted jac."""
         try:
-            document = self.workspace.get_document(file_path)
+            document = self.workspace.get_text_document(file_path)
             format = jac_str_to_pass(
                 jac_str=document.source,
                 file_path=document.path,
@@ -259,7 +274,7 @@ class JacLangServer(LanguageServer):
         self, file_path: str, position: lspt.Position
     ) -> Optional[lspt.Hover]:
         """Return hover information for a file."""
-        node_selected = find_deepest_node_at_pos(
+        node_selected = find_deepest_symbol_node_at_pos(
             self.modules[file_path].ir, position.line, position.character
         )
         value = self.get_node_info(node_selected) if node_selected else None
@@ -271,94 +286,72 @@ class JacLangServer(LanguageServer):
             )
         return None
 
-    def get_node_info(self, node: ast.AstNode) -> Optional[str]:
+    def get_node_info(self, node: ast.AstSymbolNode) -> Optional[str]:
         """Extract meaningful information from the AST node."""
         try:
-            if isinstance(node, ast.Token):
-                if isinstance(node, ast.AstSymbolNode):
-                    if isinstance(node, ast.String):
-                        return None
-                    if node.sym_link and node.sym_link.decl:
-                        decl_node = node.sym_link.decl
-                        if isinstance(decl_node, ast.Architype):
-                            if decl_node.doc:
-                                node_info = f"({decl_node.arch_type.value}) {node.value} \n{decl_node.doc.lit_value}"
-                            else:
-                                node_info = (
-                                    f"({decl_node.arch_type.value}) {node.value}"
-                                )
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.Ability):
-                            node_info = f"(ability) can {node.value}"
-                            if decl_node.signature:
-                                node_info += f" {decl_node.signature.unparse()}"
-                            if decl_node.doc:
-                                node_info += f"\n{decl_node.doc.lit_value}"
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.Name):
-                            if (
-                                decl_node.parent
-                                and isinstance(decl_node.parent, ast.SubNodeList)
-                                and decl_node.parent.parent
-                                and isinstance(decl_node.parent.parent, ast.Assignment)
-                                and decl_node.parent.parent.type_tag
-                            ):
-                                node_info = (
-                                    f"(variable) {decl_node.value}: "
-                                    f"{decl_node.parent.parent.type_tag.unparse()}"
-                                )
-                                if decl_node.parent.parent.semstr:
-                                    node_info += (
-                                        f"\n{decl_node.parent.parent.semstr.lit_value}"
-                                    )
-                            else:
-                                if decl_node.value in [
-                                    "str",
-                                    "int",
-                                    "float",
-                                    "bool",
-                                    "bytes",
-                                    "list",
-                                    "tuple",
-                                    "set",
-                                    "dict",
-                                    "type",
-                                ]:
-                                    node_info = f"({decl_node.value}) Built-in type"
-                                else:
-                                    node_info = f"(variable) {decl_node.value}: None"
-                        elif isinstance(decl_node, ast.HasVar):
-                            if decl_node.type_tag:
-                                node_info = f"(variable) {decl_node.name.value} {decl_node.type_tag.unparse()}"
-                            else:
-                                node_info = f"(variable) {decl_node.name.value}"
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.ParamVar):
-                            if decl_node.type_tag:
-                                node_info = f"(parameter) {decl_node.name.value} {decl_node.type_tag.unparse()}"
-                            else:
-                                node_info = f"(parameter) {decl_node.name.value}"
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.ModuleItem):
-                            node_info = (
-                                f"(ModuleItem) {node.value}"  # TODO: Add more info
-                            )
-                        else:
-                            node_info = f"{node.value}"
-                    else:
-                        node_info = f"{node.value}"  # non symbol node
-                else:
-                    return None
-            else:
-                return None
+            if isinstance(node, ast.NameAtom):
+                node = node.name_of
+            access = node.sym.access.value + " " if node.sym else None
+            node_info = (
+                f"({access if access else ''}{node.sym_category.value}) {node.sym_name}"
+            )
+            if node.name_spec.clean_type:
+                node_info += f": {node.name_spec.clean_type}"
+            if isinstance(node, ast.AstSemStrNode) and node.semstr:
+                node_info += f"\n{node.semstr.value}"
+            if isinstance(node, ast.AstDocNode) and node.doc:
+                node_info += f"\n{node.doc.value}"
+            if isinstance(node, ast.Ability) and node.signature:
+                node_info += f"\n{node.signature.unparse()}"
+            self.log_py(f"mypy_node: {node.gen.mypy_ast}")
         except AttributeError as e:
             self.log_warning(f"Attribute error when accessing node attributes: {e}")
         return node_info.strip()
 
+    def get_document_symbols(self, file_path: str) -> list[lspt.DocumentSymbol]:
+        """Return document symbols for a file."""
+        root_node = self.modules[file_path].ir.sym_tab
+        if root_node:
+            return collect_symbols(root_node)
+        return []
+
+    def get_definition(
+        self, file_path: str, position: lspt.Position
+    ) -> Optional[lspt.Location]:
+        """Return definition location for a file."""
+        node_selected: Optional[ast.AstSymbolNode] = find_deepest_symbol_node_at_pos(
+            self.modules[file_path].ir, position.line, position.character
+        )
+        if node_selected:
+            if isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+                return None
+            decl_node = (
+                node_selected.parent.body.target
+                if node_selected.parent
+                and isinstance(node_selected.parent, ast.AstImplNeedingNode)
+                and isinstance(node_selected.parent.body, ast.AstImplOnlyNode)
+                else (
+                    node_selected.sym.decl
+                    if (node_selected.sym and node_selected.sym.decl)
+                    else node_selected
+                )
+            )
+            self.log_py(f"{node_selected}, {decl_node}")
+            decl_uri = uris.from_fs_path(decl_node.loc.mod_path)
+            try:
+                decl_range = create_range(decl_node.loc)
+            except ValueError:  # 'print' name has decl in 0,0,0,0
+                return None
+            decl_location = lspt.Location(
+                uri=decl_uri,
+                range=decl_range,
+            )
+
+            return decl_location
+        else:
+            self.log_info("No declaration found for the selected node.")
+            return None
+
     def log_error(self, message: str) -> None:
         """Log an error message."""
         self.show_message_log(message, lspt.MessageType.Error)
@@ -373,3 +366,7 @@ class JacLangServer(LanguageServer):
         """Log an info message."""
         self.show_message_log(message, lspt.MessageType.Info)
         self.show_message(message, lspt.MessageType.Info)
+
+    def log_py(self, message: str) -> None:
+        """Log a message."""
+        logging.info(message)

jaclang/langserve/server.py

@@ -15,17 +15,19 @@ analysis_thread: Optional[threading.Thread] = None
 analysis_stop_event = threading.Event()
 
 
-def analyze_and_publish(ls: JacLangServer, uri: str) -> None:
+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)
-        ls.deep_check(uri)
-        ls.push_diagnostics(uri)
-        ls.type_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()
@@ -137,6 +139,26 @@ def hover(
     return ls.get_hover_info(params.text_document.uri, params.position)
 
 
+@server.feature(lspt.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+async 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(
+    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)
+
+
 def run_lang_server() -> None:
     """Run the language server."""
     server.start_io()

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/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):
 
@@ -66,3 +68,115 @@ class TestJacLangServer(TestCase):
         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)
+        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))),
+        )