fix: Fix completion errors in files without terminal newline

Author: armsnyder

internal/app/handler.go

@@ -56,7 +56,7 @@ func (h *Handler) Initialize(context.Context, lsp.ClientCapabilities) (*lsp.Serv
 func (h *Handler) Completion(_ context.Context, params lsp.CompletionParams) (*lsp.CompletionList, error) {
 	currentWord, c, err := h.getCompletionContext(params)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get current word: %w", err)
+		return nil, fmt.Errorf("failed to get context: %w", err)
 	}
 
 	// TODO(asnyder):
@@ -119,9 +119,15 @@ func (h *Handler) readBetweenPositions(doc *lsp.Document, startPos, endPos lsp.P
 	if err != nil {
 		return nil, fmt.Errorf("start position to offset: %w", err)
 	}
-	endOffset, err := doc.PositionToOffset(endPos)
-	if err != nil {
-		return nil, fmt.Errorf("end position to offset: %w", err)
+
+	var endOffset int
+	if endPos.Line >= doc.Lines()-1 {
+		endOffset = doc.Len()
+	} else {
+		endOffset, err = doc.PositionToOffset(endPos)
+		if err != nil {
+			return nil, fmt.Errorf("end position to offset: %w", err)
+		}
 	}
 
 	return io.ReadAll(io.NewSectionReader(doc, int64(startOffset), int64(endOffset-startOffset)))

internal/app/handler_test.go

@@ -0,0 +1,47 @@
+package app_test
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp/cmpopts"
+	. "github.com/onsi/gomega"
+
+	"github.com/armsnyder/gdshader-language-server/internal/app"
+	"github.com/armsnyder/gdshader-language-server/internal/lsp"
+)
+
+func TestHandler(t *testing.T) {
+	t.Run("completion in empty document", func(t *testing.T) {
+		g := NewWithT(t)
+		var h app.Handler
+		const uri = "file:///test.gdshader"
+
+		// Open the document.
+		err := h.DidOpenTextDocument(t.Context(), lsp.DidOpenTextDocumentParams{
+			TextDocument: lsp.TextDocumentItem{URI: uri},
+		})
+		g.Expect(err).ToNot(HaveOccurred(), "DidOpenTextDocument error")
+
+		// Type the first character.
+		err = h.DidChangeTextDocument(t.Context(), lsp.DidChangeTextDocumentParams{
+			TextDocument: lsp.TextDocumentIdentifier{URI: uri},
+			ContentChanges: []lsp.TextDocumentContentChangeEvent{{
+				Range: &lsp.Range{},
+				Text:  "s",
+			}},
+		})
+		g.Expect(err).ToNot(HaveOccurred(), "DidChangeTextDocument error")
+
+		// Get autocompletion list.
+		list, err := h.Completion(t.Context(), lsp.CompletionParams{
+			TextDocumentPositionParams: lsp.TextDocumentPositionParams{
+				TextDocument: lsp.TextDocumentIdentifier{URI: uri},
+				Position:     lsp.Position{Character: 1},
+			},
+		})
+		g.Expect(err).ToNot(HaveOccurred(), "Completion error")
+		expectedItem := lsp.CompletionItem{Label: "shader_type", Kind: lsp.CompletionKeyword}
+		ignoreFields := cmpopts.IgnoreFields(lsp.CompletionItem{}, "Detail", "Documentation")
+		g.Expect(list.Items).To(ContainElement(BeComparableTo(expectedItem, ignoreFields)), "Missing expected completion item")
+	})
+}

internal/ast/parser_test.go

@@ -30,7 +30,7 @@ import (
 
 	"github.com/alecthomas/participle/v2/lexer"
 	"github.com/armsnyder/gdshader-language-server/internal/ast"
-	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/samber/lo"
 
 	. "github.com/onsi/gomega"
@@ -81,4 +81,4 @@ func TestCanParseAllValidPrograms(t *testing.T) {
 	}
 }
 
-var IgnorePos = cmp.FilterValues(func(_, _ lexer.Position) bool { return true }, cmp.Ignore())
+var IgnorePos = cmpopts.IgnoreTypes(lexer.Position{})

internal/lsp/document_sync.go

@@ -296,6 +296,13 @@ func utf16Width(r rune) int {
 	return 2
 }
 
+// Lines returns the number of lines in the document. A single line ending in
+// a newline character is counted as two lines. This is consistent with the
+// LSP specification.
+func (d *Document) Lines() int {
+	return len(d.lineStart)
+}
+
 // ArrayBuffer is the simplest implementation of Buffer, using a byte slice
 // for storage. It is optimized for reads. Insertions and deletions are O(n)
 // due to slice copying.

internal/lsp/document_sync_test.go

@@ -89,7 +89,17 @@ func parsePos(s string) lsp.Position {
 	return lsp.Position{Line: line, Character: char}
 }
 
-func TestDocument_ApplyChange(t *testing.T) {
+func TestDocument(t *testing.T) {
+	for _, impl := range bufferImplementations {
+		t.Run(bufferName(impl), func(t *testing.T) {
+			t.Run("ApplyChange", func(t *testing.T) { testApplyChange(t, impl) })
+			t.Run("ApplyChange_Error", func(t *testing.T) { testApplyChangeError(t, impl) })
+			t.Run("PositionToOffset", func(t *testing.T) { testPositionToOffset(t, impl) })
+		})
+	}
+}
+
+func testApplyChange(t *testing.T, impl lsp.Buffer) {
 	tests := []struct {
 		name    string
 		initial string
@@ -164,25 +174,71 @@ func TestDocument_ApplyChange(t *testing.T) {
 		},
 	}
 
-	for _, impl := range bufferImplementations {
-		t.Run(bufferName(impl), func(t *testing.T) {
-			for _, tt := range tests {
-				t.Run(tt.name, func(t *testing.T) {
-					g := NewWithT(t)
-					testutil.SetupLogger(t)
-					doc := lsp.NewDocument([]byte(tt.initial), newBuffer(impl))
-					for i, change := range tt.changes {
-						err := doc.ApplyChange(change)
-						g.Expect(err).ToNot(HaveOccurred(), "ApplyChange #%d failed", i+1)
-					}
-					g.Expect(string(doc.Bytes())).To(BeComparableTo(tt.want))
-				})
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+			testutil.SetupLogger(t)
+			doc := lsp.NewDocument([]byte(tt.initial), newBuffer(impl))
+			for i, change := range tt.changes {
+				err := doc.ApplyChange(change)
+				g.Expect(err).ToNot(HaveOccurred(), "ApplyChange #%d failed", i+1)
+			}
+			g.Expect(string(doc.Bytes())).To(BeComparableTo(tt.want))
+		})
+	}
+}
+
+func testPositionToOffset(t *testing.T, impl lsp.Buffer) {
+	tests := []struct {
+		name     string
+		initial  string
+		position lsp.Position
+		want     int
+		wantErr  bool
+	}{
+		{
+			name:     "position in single line",
+			initial:  "hello world",
+			position: lsp.Position{Line: 0, Character: 5},
+			want:     5,
+		},
+		{
+			name:     "position in multi-line",
+			initial:  "hello\nworld",
+			position: lsp.Position{Line: 1, Character: 2},
+			want:     8,
+		},
+		{
+			name:     "position in multi-line with CRLF",
+			initial:  "hello\r\nworld",
+			position: lsp.Position{Line: 1, Character: 2},
+			want:     9,
+		},
+		{
+			name:     "position at end of document",
+			initial:  "hello world",
+			position: lsp.Position{Line: 0, Character: 11},
+			want:     11,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			g := NewWithT(t)
+			testutil.SetupLogger(t)
+			doc := lsp.NewDocument([]byte(tt.initial), newBuffer(impl))
+			offset, err := doc.PositionToOffset(tt.position)
+			if tt.wantErr {
+				g.Expect(err).To(HaveOccurred(), "expected error for position %v", tt.position)
+			} else {
+				g.Expect(err).ToNot(HaveOccurred(), "unexpected error for position %v", tt.position)
+				g.Expect(offset).To(BeEquivalentTo(tt.want), "unexpected offset for position %v", tt.position)
 			}
 		})
 	}
 }
 
-func TestDocument_ApplyChange_Error(t *testing.T) {
+func testApplyChangeError(t *testing.T, impl lsp.Buffer) {
 	tests := []struct {
 		name    string
 		initial string
@@ -200,14 +256,10 @@ func TestDocument_ApplyChange_Error(t *testing.T) {
 		},
 	}
 
-	for _, impl := range bufferImplementations {
-		t.Run(bufferName(impl), func(t *testing.T) {
-			for _, tt := range tests {
-				t.Run(tt.name, func(t *testing.T) {
-					doc := lsp.NewDocument([]byte(tt.initial), newBuffer(impl))
-					NewWithT(t).Expect(doc.ApplyChange(tt.change)).ToNot(Succeed())
-				})
-			}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			doc := lsp.NewDocument([]byte(tt.initial), newBuffer(impl))
+			NewWithT(t).Expect(doc.ApplyChange(tt.change)).ToNot(Succeed())
 		})
 	}
 }