Definition support for symbols

Implement initial definition support, enabling users to navigate
to symbol definitions.

internal/lsp/completion.go

@@ -16,6 +16,7 @@ import (
 
 	"go.lsp.dev/jsonrpc2"
 	"go.lsp.dev/protocol"
+	"go.lsp.dev/uri"
 )
 
 type CompletionStore struct {
@@ -69,6 +70,8 @@ type Package struct {
 }
 
 type Symbol struct {
+	Position  token.Position
+	FileURI   uri.URI
 	Name      string
 	Doc       string
 	Signature string
@@ -172,11 +175,13 @@ func InitCompletionStore(dirs []string) *CompletionStore {
 
 func getSymbols(fname string) []*Symbol {
 	var symbols []*Symbol
-
-	bsrc, err := os.ReadFile(fname)
+	absPath, err := filepath.Abs(fname)
 	if err != nil {
-		// Ignore error and return empty symbol list
-		return symbols
+		return symbols // Ignore error and return empty symbol list
+	}
+	bsrc, err := os.ReadFile(absPath)
+	if err != nil {
+		return symbols // Ignore error and return empty symbol list
 	}
 	text := string(bsrc)
 
@@ -192,17 +197,19 @@ func getSymbols(fname string) []*Symbol {
 	ast.FileExports(file)
 
 	ast.Inspect(file, func(n ast.Node) bool {
-		var found *Symbol
+		var symbol *Symbol
 
 		switch n.(type) {
 		case *ast.FuncDecl:
-			found = function(n, text)
+			symbol = function(n, text)
 		case *ast.GenDecl:
-			found = declaration(n, text)
+			symbol = declaration(n, text)
 		}
 
-		if found != nil {
-			symbols = append(symbols, found)
+		if symbol != nil {
+			symbol.FileURI = getURI(absPath)
+			symbol.Position = fset.Position(n.Pos())
+			symbols = append(symbols, symbol)
 		}
 
 		return true
@@ -255,3 +262,7 @@ func typeName(t ast.TypeSpec) string {
 		return "type"
 	}
 }
+
+func getURI(absFilePath string) uri.URI {
+	return uri.URI("file://" + absFilePath)
+}

internal/lsp/definition.go

@@ -0,0 +1,84 @@
+package lsp
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"strings"
+
+	"go.lsp.dev/jsonrpc2"
+	"go.lsp.dev/protocol"
+)
+
+func (s *server) Definition(ctx context.Context, reply jsonrpc2.Replier, req jsonrpc2.Request) error {
+	var params protocol.DefinitionParams
+	if err := json.Unmarshal(req.Params(), &params); err != nil {
+		sendParseError(ctx, reply, err)
+	}
+
+	uri := params.TextDocument.URI
+	file, ok := s.snapshot.Get(uri.Filename())
+	if !ok {
+		return reply(ctx, nil, errors.New("snapshot not found"))
+	}
+
+	offset := file.PositionToOffset(params.Position)
+	slog.Info("definition", "offset", offset)
+
+	pgf, err := file.ParseGno(ctx)
+	if err != nil {
+		return reply(ctx, nil, errors.New("cannot parse gno file"))
+	}
+
+	for _, spec := range pgf.File.Imports {
+		slog.Info("definition", "spec", spec.Path.Value, "pos", spec.Path.Pos(), "end", spec.Path.End())
+		if int(spec.Path.Pos()) <= offset && offset <= int(spec.Path.End()) {
+			// TODO: handle definition for imports
+			slog.Info("definition", "import", spec.Path.Value)
+			return reply(ctx, nil, nil)
+		}
+	}
+
+	token, err := file.TokenAt(params.Position)
+	if err != nil {
+		return reply(ctx, protocol.Hover{}, err)
+	}
+	text := strings.TrimSpace(token.Text)
+
+	// FIXME: Use the AST package to do this + get type of token.
+	//
+	// This is just a quick PoC to get something working.
+
+	// strings.Split(p.Body,
+	text = strings.Split(text, "(")[0]
+
+	text = strings.TrimSuffix(text, ",")
+	text = strings.TrimSuffix(text, ")")
+
+	// *mux.Request
+	text = strings.TrimPrefix(text, "*")
+
+	slog.Info("definition", "pkg", len(s.completionStore.pkgs))
+
+	parts := strings.Split(text, ".")
+	if len(parts) == 2 {
+		pkg := parts[0]
+		sym := parts[1]
+
+		slog.Info("definition", "pkg", pkg, "sym", sym)
+		symbol := s.completionStore.lookupSymbol(pkg, sym)
+		if symbol != nil {
+			slog.Info("definition", "URI", symbol.FileURI)
+			return reply(ctx, protocol.Location{
+				URI: symbol.FileURI,
+				Range: *posToRange(
+					symbol.Position.Line,
+					[]int{0, 0},
+				),
+			}, nil)
+		}
+	}
+
+	return reply(ctx, nil, nil)
+}

internal/lsp/server.go

@@ -69,6 +69,8 @@ func (s *server) ServerHandler(ctx context.Context, reply jsonrpc2.Replier, req
 		return s.Hover(ctx, reply, req)
 	case "textDocument/completion":
 		return s.Completion(ctx, reply, req)
+	case "textDocument/definition":
+		return s.Definition(ctx, reply, req)
 	default:
 		return jsonrpc2.MethodNotFoundHandler(ctx, reply, req)
 	}
@@ -103,6 +105,7 @@ func (s *server) Initialize(ctx context.Context, reply jsonrpc2.Replier, req jso
 					"gnopls.version",
 				},
 			},
+			DefinitionProvider:         true,
 			DocumentFormattingProvider: true,
 		},
 	}, nil)