Working base

Author: yuval-po

cmd/lspdev/main.go

@@ -5,11 +5,16 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"net"
 	"os"
-	"os/exec"
 	"strconv"
 	"strings"
 	"sync"
+	"time"
+
+	"github.com/gopher-fleece/gleece/v2/internal/lsp/server"
+	"github.com/gopher-fleece/gleece/v2/internal/lsp/server/ipc"
+	protocol "github.com/tliron/glsp/protocol_3_16"
 )
 
 type lspRequest struct {
@@ -27,39 +32,18 @@ type lspResponse struct {
 }
 
 type LSPClient struct {
-	stdin  io.WriteCloser
-	stdout io.ReadCloser
-	stderr io.ReadCloser
+	conn   io.ReadWriteCloser
+	reader *bufio.Reader
 	mu     sync.Mutex
 	nextID int64
 }
 
-func newLSPClient(cmd *exec.Cmd) (*LSPClient, error) {
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return nil, err
-	}
-
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, err
-	}
-
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		return nil, err
-	}
-
-	if err := cmd.Start(); err != nil {
-		return nil, err
-	}
-
+func newLSPClient(conn io.ReadWriteCloser) *LSPClient {
 	return &LSPClient{
-		stdin:  stdin,
-		stdout: stdout,
-		stderr: stderr,
+		conn:   conn,
+		reader: bufio.NewReader(conn),
 		nextID: 1,
-	}, nil
+	}
 }
 
 func (c *LSPClient) Send(method string, params any) (*lspResponse, error) {
@@ -81,18 +65,16 @@ func (c *LSPClient) Send(method string, params any) (*lspResponse, error) {
 		return nil, err
 	}
 
-	if _, err := fmt.Fprintf(c.stdin, "Content-Length: %d\r\n\r\n", len(payload)); err != nil {
+	if _, err := fmt.Fprintf(c.conn, "Content-Length: %d\r\n\r\n", len(payload)); err != nil {
 		return nil, err
 	}
-	if _, err := c.stdin.Write(payload); err != nil {
+	if _, err := c.conn.Write(payload); err != nil {
 		return nil, err
 	}
 
-	reader := bufio.NewReader(c.stdout)
-
 	contentLength := 0
 	for {
-		line, err := reader.ReadString('\n')
+		line, err := c.reader.ReadString('\n')
 		if err != nil {
 			return nil, err
 		}
@@ -112,7 +94,7 @@ func (c *LSPClient) Send(method string, params any) (*lspResponse, error) {
 	}
 
 	body := make([]byte, contentLength)
-	if _, err := io.ReadFull(reader, body); err != nil {
+	if _, err := io.ReadFull(c.reader, body); err != nil {
 		return nil, err
 	}
 
@@ -124,16 +106,36 @@ func (c *LSPClient) Send(method string, params any) (*lspResponse, error) {
 	return &resp, nil
 }
 
+func (c *LSPClient) Close() error {
+	return c.conn.Close()
+}
+
 func runLsp() *LSPClient {
-	// Replace this with the actual server executable entrypoint you want to launch.
-	cmd := exec.Command(os.Args[0])
+	const address = "127.0.0.1:43891"
 
-	client, err := newLSPClient(cmd)
+	langServer, err := server.NewLanguageServer(ipc.TcpOptions{
+		Address: address,
+	})
 	if err != nil {
 		panic(err)
 	}
 
-	return client
+	go func() {
+		if err := langServer.Run(); err != nil {
+			panic(err)
+		}
+	}()
+
+	var conn net.Conn
+	for range 20 {
+		conn, err = net.Dial("tcp", address)
+		if err == nil {
+			return newLSPClient(conn)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	panic(fmt.Errorf("failed to connect to lsp server at %s: %w", address, err))
 }
 
 func sendInit(client *LSPClient) {
@@ -146,16 +148,35 @@ func sendInit(client *LSPClient) {
 		panic(err)
 	}
 
-	fmt.Println(string(resp.Result))
+	fmt.Printf("Current PID: %v, Resp: %v", os.Getpid(), string(resp.Result))
+}
+
+func sendDidChangeTextDocument(client *LSPClient, uri string) {
+	body := protocol.DidChangeTextDocumentParams{
+		TextDocument: protocol.VersionedTextDocumentIdentifier{
+			TextDocumentIdentifier: protocol.TextDocumentIdentifier{
+				URI: uri,
+			},
+		},
+	}
+
+	resp, err := client.Send("textDocument/didChange", body)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("Current PID: %v, Resp: %v", os.Getpid(), string(resp.Result))
 }
 
 func main() {
 	client := runLsp()
 	defer func() {
-		_ = client.stdin.Close()
-		_ = client.stdout.Close()
-		_ = client.stderr.Close()
+		_ = client.Close()
 	}()
 
 	sendInit(client)
+	sendDidChangeTextDocument(
+		client,
+		"/mnt/7e91759c-6dd7-4c99-8d38-e6422452a469/git/gleece/test/sanity/sanity.controller.go",
+	)
 }

internal/lsp/core/analyzer/analyzer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/gopher-fleece/gleece/v2/core/pipeline"
+	"github.com/gopher-fleece/gleece/v2/core/validators/diagnostics"
 	"github.com/gopher-fleece/gleece/v2/definitions"
 	"github.com/gopher-fleece/gleece/v2/gast"
 	"github.com/tliron/glsp"
@@ -52,14 +53,18 @@ func (analyzer *GleeceAnalyzer) invalidateFile(ctx *glsp.Context, filePath strin
 			return pipeErr
 		}
 
-		go ctx.Notify(
-			protocol.ServerTextDocumentPublishDiagnostics,
-			protocol.PublishDiagnosticsParams{
-				URI:         filePath,
-				Diagnostics: entityDiagsToLsp(diags),
-			},
-		)
+		analyzer.pushDiagnosticsAsync(ctx, filePath, diags)
 	}
 
 	return nil
 }
+
+func (analyzer *GleeceAnalyzer) pushDiagnosticsAsync(ctx *glsp.Context, fileUri string, diagnostics []diagnostics.EntityDiagnostic) {
+	go ctx.Notify(
+		protocol.ServerTextDocumentPublishDiagnostics,
+		protocol.PublishDiagnosticsParams{
+			URI:         fileUri,
+			Diagnostics: entityDiagsToLsp(diagnostics),
+		},
+	)
+}

internal/lsp/handlers/initialization.go

@@ -1,12 +1,26 @@
 package handlers
 
 import (
+	"github.com/gopher-fleece/gleece/v2/cmd"
 	"github.com/gopher-fleece/gleece/v2/internal/lsp/common"
+	"github.com/gopher-fleece/gleece/v2/internal/lsp/core/analyzer"
 	"github.com/tliron/glsp"
 	protocol "github.com/tliron/glsp/protocol_3_16"
 )
 
 func (h *ProtocolHandler) initialize(ctx *glsp.Context, params *protocol.InitializeParams) (any, error) {
+	config, err := cmd.LoadGleeceConfig("/mnt/7e91759c-6dd7-4c99-8d38-e6422452a469/git/gleece/gleece.config.json")
+	if err != nil {
+		return nil, err
+	}
+
+	analyzerInstance, err := analyzer.NewGleeceAnalyzer(config)
+	if err != nil {
+		return nil, err
+	}
+
+	h.state.Analyzer = analyzerInstance
+
 	return protocol.InitializeResult{
 		Capabilities: protocol.ServerCapabilities{
 			TextDocumentSync: protocol.TextDocumentSyncKindFull,
@@ -18,5 +32,10 @@ func (h *ProtocolHandler) initialize(ctx *glsp.Context, params *protocol.Initial
 }
 
 func (h *ProtocolHandler) initialized(ctx *glsp.Context, params *protocol.InitializedParams) error {
+	err := h.state.Analyzer.Pipeline.GenerateGraph()
+	if err != nil {
+		return err
+	}
+
 	return nil
 }

internal/lsp/server/enums.go internal/lsp/server/ipc/common.gointernal/lsp/server/enums.go renamed to internal/lsp/server/ipc/common.go

@@ -1,4 +1,4 @@
-package server
+package ipc
 
 type LangServerIpcType string
 

internal/lsp/server/ipc/stdio.go

@@ -0,0 +1,6 @@
+package ipc
+
+type StdIoOptions struct{}
+
+func (StdIoOptions) IpcType() LangServerIpcType { return LangServerIpcStdIo }
+func (StdIoOptions) Validate() error            { return nil }

internal/lsp/server/ipc/tcp.go

@@ -0,0 +1,16 @@
+package ipc
+
+import "fmt"
+
+type TcpOptions struct {
+	Address string
+}
+
+func (TcpOptions) IpcType() LangServerIpcType { return LangServerIpcTcp }
+
+func (o TcpOptions) Validate() error {
+	if o.Address == "" {
+		return fmt.Errorf("address is required for tcp ipc type")
+	}
+	return nil
+}

internal/lsp/server/server.go

@@ -5,37 +5,43 @@ import (
 
 	"github.com/gopher-fleece/gleece/v2/internal/lsp/common"
 	"github.com/gopher-fleece/gleece/v2/internal/lsp/handlers"
+	"github.com/gopher-fleece/gleece/v2/internal/lsp/server/ipc"
 	"github.com/gopher-fleece/gleece/v2/internal/lsp/state"
 	"github.com/tliron/glsp/server"
 )
 
-type LangServerOptions struct {
-	Ipc LangServerIpcType
+type LangServerOptions interface {
+	IpcType() ipc.LangServerIpcType
+	Validate() error
 }
 
 type LanguageServer struct {
-	ipcType LangServerIpcType
+	options LangServerOptions
 }
 
 func NewLanguageServer(opts LangServerOptions) (*LanguageServer, error) {
-	if opts.Ipc == "" || (opts.Ipc != LangServerIpcStdIo) {
-		return nil, fmt.Errorf("ipc type '%s' is not currently supported", opts.Ipc)
+	if opts == nil {
+		return nil, fmt.Errorf("options are required")
 	}
 
-	return &LanguageServer{
-		ipcType: opts.Ipc,
-	}, nil
+	if err := opts.Validate(); err != nil {
+		return nil, err
+	}
+
+	return &LanguageServer{options: opts}, nil
 }
 
 func (s *LanguageServer) Run() error {
 	state := state.WorkspaceState{}
 	handler := handlers.GetProtocolHandler(&state)
 	srv := server.NewServer(&handler, common.LangSrvName, false)
 
-	switch s.ipcType {
-	case LangServerIpcStdIo:
+	switch opts := s.options.(type) {
+	case ipc.StdIoOptions:
 		return srv.RunStdio()
+	case ipc.TcpOptions:
+		return srv.RunTCP(opts.Address)
 	default:
-		return fmt.Errorf("unknown or unsupported ipc type '%s'", s.ipcType)
+		return fmt.Errorf("unknown or unsupported ipc type '%s'", opts.IpcType())
 	}
 }

internal/lsp/state/workspace.go

@@ -3,7 +3,7 @@ package state
 import "github.com/gopher-fleece/gleece/v2/internal/lsp/core/analyzer"
 
 type WorkspaceState struct {
-	Analyzer  analyzer.GleeceAnalyzer
+	Analyzer  *analyzer.GleeceAnalyzer
 	Documents DocumentsState
 	Config    ExtensionConfig
 }