Removed useless logic from AsyncHandler

Author: cmaglie

handler/builder.go

@@ -94,9 +94,9 @@ func (handler *InoHandler) rebuildEnvironmentLoop() {
 			}
 		}()
 
-		handler.synchronizer.DataMux.Lock()
+		handler.dataMux.Lock()
 		handler.initializeWorkbench(nil)
-		handler.synchronizer.DataMux.Unlock()
+		handler.dataMux.Unlock()
 		done <- true
 		close(done)
 	}

handler/handler.go

@@ -27,23 +27,24 @@ import (
 var globalCliPath string
 var globalClangdPath string
 var enableLogging bool
-var asyncProcessing bool
 
 // Setup initializes global variables.
-func Setup(cliPath string, clangdPath string, _enableLogging bool, _asyncProcessing bool) {
+func Setup(cliPath string, clangdPath string, _enableLogging bool) {
 	globalCliPath = cliPath
 	globalClangdPath = clangdPath
 	enableLogging = _enableLogging
-	asyncProcessing = _asyncProcessing
 }
 
 // CLangdStarter starts clangd and returns its stdin/out/err
 type CLangdStarter func() (stdin io.WriteCloser, stdout io.ReadCloser, stderr io.ReadCloser)
 
 // InoHandler is a JSON-RPC handler that delegates messages to clangd.
 type InoHandler struct {
-	StdioConn                  *jsonrpc2.Conn
-	ClangdConn                 *jsonrpc2.Conn
+	StdioConn  *jsonrpc2.Conn
+	ClangdConn *jsonrpc2.Conn
+
+	clangdStarted              *sync.Cond
+	dataMux                    sync.RWMutex
 	lspInitializeParams        *lsp.InitializeParams
 	buildPath                  *paths.Path
 	buildSketchRoot            *paths.Path
@@ -61,8 +62,7 @@ type InoHandler struct {
 	docs                       map[string]*lsp.TextDocumentItem
 	inoDocsWithDiagnostics     map[string]bool
 
-	config       lsp.BoardConfig
-	synchronizer Synchronizer
+	config lsp.BoardConfig
 }
 
 // NewInoHandler creates and configures an InoHandler.
@@ -74,15 +74,9 @@ func NewInoHandler(stdio io.ReadWriteCloser, board lsp.Board) *InoHandler {
 			SelectedBoard: board,
 		},
 	}
-
+	handler.clangdStarted = sync.NewCond(&handler.dataMux)
 	stdStream := jsonrpc2.NewBufferedStream(stdio, jsonrpc2.VSCodeObjectCodec{})
 	var stdHandler jsonrpc2.Handler = jsonrpc2.HandlerWithError(handler.HandleMessageFromIDE)
-	if asyncProcessing {
-		stdHandler = AsyncHandler{
-			handler:      stdHandler,
-			synchronizer: &handler.synchronizer,
-		}
-	}
 	handler.StdioConn = jsonrpc2.NewConn(context.Background(), stdStream, stdHandler)
 	if enableLogging {
 		log.Println("Initial board configuration:", board)
@@ -118,11 +112,23 @@ func (handler *InoHandler) HandleMessageFromIDE(ctx context.Context, conn *jsonr
 		"textDocument/didClose":  true,
 	}
 	if needsWriteLock[req.Method] {
-		handler.synchronizer.DataMux.Lock()
-		defer handler.synchronizer.DataMux.Unlock()
+		handler.dataMux.Lock()
+		defer handler.dataMux.Unlock()
 	} else {
-		handler.synchronizer.DataMux.RLock()
-		defer handler.synchronizer.DataMux.RUnlock()
+		handler.dataMux.RLock()
+		defer handler.dataMux.RUnlock()
+	}
+
+	// Wait for clangd start-up
+	doNotNeedClangd := map[string]bool{
+		"initialize":  true,
+		"initialized": true,
+	}
+	if handler.ClangdConn == nil && !doNotNeedClangd[req.Method] {
+		handler.clangdStarted.Wait()
+		if handler.ClangdConn == nil {
+			return nil, errors.New("could not run clangd, aborted")
+		}
 	}
 
 	// Handle LSP methods: transform parameters and send to clangd

handler/syncer.go

@@ -2,46 +2,16 @@ package handler
 
 import (
 	"context"
-	"sync"
 
 	"github.com/sourcegraph/jsonrpc2"
 )
 
-// Synchronizer is used to block message processing while an edit or config change is applied.
-type Synchronizer struct {
-	// FileMux is a read/write mutex for file access. It is locked during the processing of
-	// messages that modify target files for clangd.
-	FileMux sync.RWMutex
-	// DataMux is a mutex for document metadata access, i.e. source-target URI mappings and line mappings.
-	DataMux sync.RWMutex
-}
-
 // AsyncHandler wraps a Handler such that each request is handled in its own goroutine.
 type AsyncHandler struct {
-	handler      jsonrpc2.Handler
-	synchronizer *Synchronizer
+	handler jsonrpc2.Handler
 }
 
 // Handle handles a request or notification
 func (ah AsyncHandler) Handle(ctx context.Context, conn *jsonrpc2.Conn, req *jsonrpc2.Request) {
-	needsWriteLock := req.Method == "textDocument/didOpen" || req.Method == "textDocument/didChange"
-	if needsWriteLock {
-		go func() {
-			ah.synchronizer.FileMux.Lock()
-			defer ah.synchronizer.FileMux.Unlock()
-			if enableLogging {
-				// log.Println("Message processing locked for", req.Method)
-			}
-			ah.handler.Handle(ctx, conn, req)
-			if enableLogging {
-				// log.Println("Message processing unlocked for", req.Method)
-			}
-		}()
-	} else {
-		go func() {
-			ah.synchronizer.FileMux.RLock()
-			ah.handler.Handle(ctx, conn, req)
-			ah.synchronizer.FileMux.RUnlock()
-		}()
-	}
+	go ah.handler.Handle(ctx, conn, req)
 }

main.go

@@ -44,7 +44,7 @@ func main() {
 		log.SetOutput(os.Stderr)
 	}
 
-	handler.Setup(cliPath, clangdPath, enableLogging, true)
+	handler.Setup(cliPath, clangdPath, enableLogging)
 	initialBoard := lsp.Board{Fqbn: initialFqbn, Name: initialBoardName}
 
 	stdio := streams.NewReadWriteCloser(os.Stdin, os.Stdout)