On parse failure, keep the old AST

pkg/server/cache.go

@@ -12,7 +12,10 @@ import (
 type document struct {
 	// From DidOpen and DidChange
 	item protocol.TextDocumentItem
-	ast  ast.Node
+
+	// Contains the last succesfully parsed AST. If doc.err is not nil, it's out of date.
+	ast                  ast.Node
+	linesChangedSinceAST map[int]bool
 
 	// From diagnostics
 	val         string

pkg/server/definition.go

@@ -44,8 +44,12 @@ func (s *server) definitionLink(ctx context.Context, params *protocol.Definition
 		return nil, utils.LogErrorf("Definition: %s: %w", errorRetrievingDocument, err)
 	}
 
+	// Only find definitions, if the the line we're trying to find a definition for hasn't changed since last succesful AST parse
 	if doc.ast == nil {
-		return nil, utils.LogErrorf("Definition: %s", errorParsingDocument)
+		return nil, utils.LogErrorf("Definition: document was never successfully parsed, can't find definitions")
+	}
+	if doc.linesChangedSinceAST[int(params.Position.Line)] {
+		return nil, utils.LogErrorf("Definition: document line %d was changed since last successful parse, can't find definitions", params.Position.Line)
 	}
 
 	vm, err := s.getVM(doc.item.URI.SpanURI().Filename())

pkg/server/hover.go

@@ -19,7 +19,7 @@ func (s *server) Hover(ctx context.Context, params *protocol.HoverParams) (*prot
 		return nil, utils.LogErrorf("Hover: %s: %w", errorRetrievingDocument, err)
 	}
 
-	if doc.ast == nil {
+	if doc.err != nil {
 		// Hover triggers often. Throwing an error on each request is noisy
 		log.Errorf("Hover: %s", errorParsingDocument)
 		return nil, nil

pkg/server/server.go

@@ -3,8 +3,10 @@ package server
 import (
 	"context"
 	"path/filepath"
+	"strings"
 
 	"github.com/google/go-jsonnet"
+	"github.com/google/go-jsonnet/ast"
 	"github.com/grafana/jsonnet-language-server/pkg/stdlib"
 	"github.com/grafana/jsonnet-language-server/pkg/utils"
 	tankaJsonnet "github.com/grafana/tanka/pkg/jsonnet"
@@ -73,10 +75,28 @@ func (s *server) DidChange(ctx context.Context, params *protocol.DidChangeTextDo
 	}
 
 	if params.TextDocument.Version > doc.item.Version && len(params.ContentChanges) != 0 {
+		oldText := doc.item.Text
 		doc.item.Text = params.ContentChanges[len(params.ContentChanges)-1].Text
-		doc.ast, doc.err = jsonnet.SnippetToAST(doc.item.URI.SpanURI().Filename(), doc.item.Text)
-		if doc.err != nil {
-			return s.cache.put(doc)
+
+		var ast ast.Node
+		ast, doc.err = jsonnet.SnippetToAST(doc.item.URI.SpanURI().Filename(), doc.item.Text)
+
+		// If the AST parsed correctly, set it on the document
+		// Otherwise, keep the old AST, and find all the lines that have changed since last AST
+		if ast != nil {
+			doc.ast = ast
+			doc.linesChangedSinceAST = map[int]bool{}
+		} else {
+			splitOldText := strings.Split(oldText, "\n")
+			splitNewText := strings.Split(doc.item.Text, "\n")
+			for index, oldLine := range splitOldText {
+				if index >= len(splitNewText) {
+					doc.linesChangedSinceAST[index] = true
+				}
+				if oldLine != splitNewText[index] {
+					doc.linesChangedSinceAST[index] = true
+				}
+			}
 		}
 	}
 	return nil
@@ -85,12 +105,9 @@ func (s *server) DidChange(ctx context.Context, params *protocol.DidChangeTextDo
 func (s *server) DidOpen(ctx context.Context, params *protocol.DidOpenTextDocumentParams) (err error) {
 	defer s.queueDiagnostics(params.TextDocument.URI)
 
-	doc := &document{item: params.TextDocument}
+	doc := &document{item: params.TextDocument, linesChangedSinceAST: map[int]bool{}}
 	if params.TextDocument.Text != "" {
 		doc.ast, doc.err = jsonnet.SnippetToAST(params.TextDocument.URI.SpanURI().Filename(), params.TextDocument.Text)
-		if doc.err != nil {
-			return s.cache.put(doc)
-		}
 	}
 	return s.cache.put(doc)
 }

pkg/server/symbols.go

@@ -20,7 +20,7 @@ func (s *server) DocumentSymbol(ctx context.Context, params *protocol.DocumentSy
 		return nil, utils.LogErrorf("DocumentSymbol: %s: %w", errorRetrievingDocument, err)
 	}
 
-	if doc.ast == nil {
+	if doc.err != nil {
 		// Returning an error too often can lead to the client killing the language server
 		// Logging the errors is sufficient
 		log.Errorf("DocumentSymbol: %s", errorParsingDocument)