feat(lsp): add go to definition for ctes

Author: benfdking

sqlmesh/lsp/main.py

@@ -265,21 +265,31 @@ def goto_definition(
                     raise RuntimeError(f"No context found for document: {document.path}")
 
                 references = get_references(self.lsp_context, uri, params.position)
-                return [
-                    types.LocationLink(
-                        target_uri=reference.uri,
-                        target_selection_range=types.Range(
+                location_links = []
+                for reference in references:
+                    # Use target_range if available (for CTEs), otherwise default to start of file
+                    if reference.target_range:
+                        target_range = reference.target_range
+                        target_selection_range = reference.target_range
+                    else:
+                        target_range = types.Range(
                             start=types.Position(line=0, character=0),
                             end=types.Position(line=0, character=0),
-                        ),
-                        target_range=types.Range(
+                        )
+                        target_selection_range = types.Range(
                             start=types.Position(line=0, character=0),
                             end=types.Position(line=0, character=0),
-                        ),
-                        origin_selection_range=reference.range,
+                        )
+
+                    location_links.append(
+                        types.LocationLink(
+                            target_uri=reference.uri,
+                            target_selection_range=target_selection_range,
+                            target_range=target_range,
+                            origin_selection_range=reference.range,
+                        )
                     )
-                    for reference in references
-                ]
+                return location_links
             except Exception as e:
                 ls.show_message(f"Error getting references: {e}", types.MessageType.Error)
                 return []

sqlmesh/lsp/reference.py

@@ -11,17 +11,19 @@
 
 class Reference(PydanticModel):
     """
-    A reference to a model.
+    A reference to a model or CTE.
 
     Attributes:
         range: The range of the reference in the source file
-        uri: The uri of the referenced model
-        description: The description of the referenced model
+        uri: The uri of the referenced model or file
+        description: The description of the referenced model or CTE
+        target_range: The range of the definition for go-to-definition (optional, used for CTEs)
     """
 
     range: Range
     uri: str
     description: t.Optional[str] = None
+    target_range: t.Optional[Range] = None
 
 
 def by_position(position: Position) -> t.Callable[[Reference], bool]:
@@ -87,6 +89,7 @@ def get_model_definitions_for_a_path(
     - Need to normalize it before matching
     - Try get_model before normalization
     - Match to models that the model refers to
+    - Also find CTE references within the query
     """
     path = document_uri.to_path()
     if path.suffix != ".sql":
@@ -127,13 +130,49 @@ def get_model_definitions_for_a_path(
 
     # Get SQL query and find all table references
     tables = list(query.find_all(exp.Table))
-    if len(tables) == 0:
-        return []
 
     with open(file_path, "r", encoding="utf-8") as file:
         read_file = file.readlines()
 
+    # Build a map of CTE names to their definitions for CTE go-to-definition
+    cte_definitions = {}
+    with_clause = query.find(exp.With)
+    if with_clause:
+        for cte in with_clause.expressions:
+            if isinstance(cte.alias, str):
+                cte_definitions[cte.alias] = cte
+
     for table in tables:
+        table_name = table.name
+
+        # Check if this table reference is a CTE
+        if table_name in cte_definitions:
+            try:
+                # This is a CTE reference - create a reference to the CTE definition
+                cte_def = cte_definitions[table_name]
+                args = cte_def.args["alias"]
+                if args and isinstance(args, exp.TableAlias):
+                    identifier = args.this
+                    if isinstance(identifier, exp.Identifier):
+                        meta = identifier.meta
+
+                        table_meta = TokenPositionDetails.from_meta(meta)
+                        target_range = _range_from_token_position_details(table_meta, read_file)
+                        table_meta = TokenPositionDetails.from_meta(table.this.meta)
+                        table_range = _range_from_token_position_details(table_meta, read_file)
+
+                        references.append(
+                            Reference(
+                                uri=document_uri.value,  # Same file
+                                range=table_range,
+                                target_range=target_range,
+                            )
+                        )
+            except Exception:
+                pass
+            continue
+
+        # For non-CTE tables, process as before (external model references)
         # Normalize the table reference
         unaliased = table.copy()
         if unaliased.args.get("alias") is not None:

tests/lsp/test_reference_cte.py

@@ -0,0 +1,47 @@
+import re
+from sqlmesh.core.context import Context
+from sqlmesh.lsp.context import LSPContext, ModelTarget
+from sqlmesh.lsp.reference import get_references
+from sqlmesh.lsp.uri import URI
+from lsprotocol.types import Range, Position
+import typing as t
+
+
+def test_cte_parsing():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    # Find model URIs
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    # Find position of the cte reference
+    ranges = find_ranges_from_regex(read_file, r"current_marketing")
+    assert len(ranges) == 2
+    # Middle of the second range
+    position = Position(line=ranges[1].start.line, character=ranges[1].start.character + 4)
+
+    references = get_references(lsp_context, URI.from_path(sushi_customers_path), position)
+
+    assert len(references) == 1
+    assert references[0].uri == URI.from_path(sushi_customers_path).value
+    assert references[0].description is None
+    assert references[0].range == ranges[1]
+
+
+def find_ranges_from_regex(read_file: t.List[str], regex: str) -> t.List[Range]:
+    """Find all ranges in the read file that match the regex."""
+    return [
+        Range(
+            start=Position(line=line_number, character=match.start()),
+            end=Position(line=line_number, character=match.end()),
+        )
+        for line_number, line in enumerate(read_file)
+        for match in [m for m in [re.search(regex, line)] if m]
+    ]