From 93c89766cbbee2ea8ad726ef8aa2550f737e33e1 Mon Sep 17 00:00:00 2001
From: karitham <kar@karitham.dev>
Date: Sat, 8 Aug 2026 00:54:22 +0200
Subject: [PATCH] completion: keep type slots type-only and qualify imported
 types

---
 lsp/source/completion_type_slot_test.go | 75 +++++++++++++++++++++++++
 lsp/source/context.go                   | 49 ++++++++++++++--
 lsp/source/context_test.go              |  6 ++
 lsp/source/semantic_completion.go       | 28 +++++++--
 lsp/source/slot_completion_test.go      |  5 +-
 5 files changed, 149 insertions(+), 14 deletions(-)
 create mode 100644 lsp/source/completion_type_slot_test.go

diff --git a/lsp/source/completion_type_slot_test.go b/lsp/source/completion_type_slot_test.go
new file mode 100644
index 0000000..559ed01
--- /dev/null
+++ b/lsp/source/completion_type_slot_test.go
@@ -0,0 +1,75 @@
+package source
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/karitham/thrift-ls/lsp/cache"
+)
+
+// TestCompletionTypeSlotNoLeaks pins that type slots only suggest types:
+// no enum values, consts, or identifier-token dumps leak in when the
+// parser cannot complete the construct (openers like map< and keywords
+// like const/typedef).
+func TestCompletionTypeSlotNoLeaks(t *testing.T) {
+	inc := `enum Song {
+	FUWA_FUWA_TIME = 1
+}
+
+const i32 TEMPO = 120
+
+struct Album {
+	1: required string title
+}`
+
+	tests := []struct {
+		name   string
+		marker string
+	}{
+		{name: "after map opener", marker: "1: required map<"},
+		{name: "after list opener", marker: "1: required list<"},
+		{name: "after set opener", marker: "1: required set<"},
+		{name: "after const", marker: "const "},
+		{name: "after typedef", marker: "typedef "},
+		{name: "map value after comma", marker: "1: required map<i32, "},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			content := "include \"songs.thrift\"\nstruct Club {\n\t" + tt.marker + "\n}"
+
+			ss := buildSnapshot(t, nil,
+				&cache.FileChange{URI: "file:///tmp/songs.thrift", Version: 0, Content: []byte(inc), From: cache.FileChangeTypeDidOpen},
+				&cache.FileChange{URI: "file:///tmp/club.thrift", Version: 0, Content: []byte(content), From: cache.FileChangeTypeDidOpen},
+			)
+
+			pos := lspPosOf(t, content, tt.marker)
+
+			labels, _, _ := completionLabels(t, ss, "file:///tmp/club.thrift", pos)
+
+			assert.NotContains(t, labels, "FUWA_FUWA_TIME", "enum values must not leak into a type slot")
+			assert.NotContains(t, labels, "TEMPO", "consts must not leak into a type slot")
+			assert.NotContains(t, labels, "Song", "enum names are types but must not appear bare from another file")
+		})
+	}
+}
+
+// TestCompletionImportedTypesQualified pins that types from included files
+// are suggested with their include qualifier: a bare Album reference does
+// not resolve from club.thrift, so typing "so" must surface songs.Album —
+// never a bare Album.
+func TestCompletionImportedTypesQualified(t *testing.T) {
+	content := "include \"songs.thrift\"\nstruct Club {\n\t1: required so\n}"
+
+	ss := buildSnapshot(t, nil,
+		&cache.FileChange{URI: "file:///tmp/songs.thrift", Version: 0, Content: []byte("struct Album {\n\t1: required string title\n}\n"), From: cache.FileChangeTypeDidOpen},
+		&cache.FileChange{URI: "file:///tmp/club.thrift", Version: 0, Content: []byte(content), From: cache.FileChangeTypeDidOpen},
+	)
+
+	pos := lspPosOf(t, content, "required so")
+
+	labels, _, _ := completionLabels(t, ss, "file:///tmp/club.thrift", pos)
+
+	assert.Equal(t, []string{"songs.Album"}, labels, "labels: %v", labels)
+}
diff --git a/lsp/source/context.go b/lsp/source/context.go
index d816794..b2ab6c4 100644
--- a/lsp/source/context.go
+++ b/lsp/source/context.go
@@ -120,10 +120,20 @@ func ResolveContext(doc *syntax.Document, pos syntax.Position) Context {
 		case syntax.TokenComma, syntax.TokenSemicolon:
 			if opener, ok := parenOpener(doc, prevIdx); ok {
 				c.Kind = insideParenKind(doc, opener)
+			} else if _, ok := ltOpener(doc, prevIdx); ok {
+				// Inside a container type: map<i32, | is a type slot.
+				c.Kind = CtxType
 			} else if kw, ok := braceBodyKind(doc, prevIdx); ok {
 				c.Kind = memberKind(kw)
 			}
 
+			return c
+		case syntax.TokenLt, syntax.TokenConst, syntax.TokenTypedef:
+			// After a container opener or a const/typedef keyword: a type
+			// slot. The parser bails on the incomplete construct, so the
+			// keyword fallback would otherwise leak every identifier.
+			c.Kind = CtxType
+
 			return c
 		case syntax.TokenLBrace:
 			if kw, ok := braceBodyKind(doc, prevIdx); ok {
@@ -149,12 +159,17 @@ func ResolveContext(doc *syntax.Document, pos syntax.Position) Context {
 
 			return c
 		case syntax.TokenIdentifier:
-			// "user.|" — the lexer drops a trailing dot, so the
-			// identifier token ends one byte before the cursor and the
-			// byte between them is the dot. The slot of the identifier
-			// decides: a type position keeps the type kind with the
-			// dotted prefix (the type provider scopes to the include),
-			// anything else is a qualified value.
+			// The identifier at the cursor. Mid-type typing ("required
+			// so|") is a type slot when the identifier sits directly
+			// after a type marker; "songs.|" drops the trailing dot (one
+			// byte before the cursor) and must keep the dotted prefix so
+			// the type provider scopes to the include.
+			if prev.Offset+len(prev.Text) == c.Offset && typeSlotAfterIdent(doc, prevIdx) {
+				c.Kind = CtxType
+
+				return c
+			}
+
 			if prev.Offset+len(prev.Text) == c.Offset-1 {
 				if typeSlotAfterIdent(doc, prevIdx) {
 					c.Kind = CtxType
@@ -500,6 +515,28 @@ func parenOpener(doc *syntax.Document, from int) (int, bool) {
 	return 0, false
 }
 
+// ltOpener returns the index of the nearest unclosed '<' at or before from.
+// Containers only appear in type positions, so an unclosed opener means
+// the cursor is inside a container type.
+func ltOpener(doc *syntax.Document, from int) (int, bool) {
+	depth := 0
+
+	for i := from; i >= 0; i-- {
+		switch doc.Tokens[i].Kind {
+		case syntax.TokenGt:
+			depth++
+		case syntax.TokenLt:
+			if depth == 0 {
+				return i, true
+			}
+
+			depth--
+		}
+	}
+
+	return 0, false
+}
+
 // braceBodyKind returns the container keyword (struct/union/exception/enum/
 // service) of the nearest enclosing brace body at or before from.
 func braceBodyKind(doc *syntax.Document, from int) (syntax.TokenKind, bool) {
diff --git a/lsp/source/context_test.go b/lsp/source/context_test.go
index 2c0b5df..112d8fa 100644
--- a/lsp/source/context_test.go
+++ b/lsp/source/context_test.go
@@ -76,6 +76,12 @@ func TestResolveContext(t *testing.T) {
 		{"field name on identifier", `struct Gundam { 1: required string Na|me }`, CtxFieldName},
 		{"field type on identifier", `struct Gundam { 1: required Str|ing Name }`, CtxType},
 		{"map key type", `struct Gundam { 1: map<|i32, string> fields }`, CtxType},
+		{"type slot after map opener", `struct Gundam { 1: map<|}`, CtxType},
+		{"type slot after list opener", `struct Gundam { 1: list<|}`, CtxType},
+		{"type slot after set opener", `struct Gundam { 1: set<|}`, CtxType},
+		{"map value type after comma", `struct Gundam { 1: map<i32, |}`, CtxType},
+		{"const type slot", `const |`, CtxType},
+		{"typedef type slot", `typedef |`, CtxType},
 		{"field after annotations", `struct Gundam { 1: string Name (color = "blue") |}`, CtxKeyword},
 
 		// Values.
diff --git a/lsp/source/semantic_completion.go b/lsp/source/semantic_completion.go
index 293beae..49b6bd2 100644
--- a/lsp/source/semantic_completion.go
+++ b/lsp/source/semantic_completion.go
@@ -51,12 +51,6 @@ func typeCandidates(ctx context.Context, ss *cache.Snapshot, file uri.URI, c Con
 	names := make(map[string]struct{})
 	collectTypeNames(c.Doc, names)
 
-	for _, inc := range includedFiles(ss, file) {
-		if pf, err := ss.Parse(ctx, inc); err == nil && pf.AST() != nil {
-			collectTypeNames(pf.AST(), names)
-		}
-	}
-
 	var res []Candidate
 	for name := range names {
 		res = append(res, Candidate{
@@ -66,6 +60,28 @@ func typeCandidates(ctx context.Context, ss *cache.Snapshot, file uri.URI, c Con
 		})
 	}
 
+	// Types from included files are suggested with their include
+	// qualifier: a bare reference to an imported type does not resolve.
+	for _, inc := range includedFiles(ss, file) {
+		pf, err := ss.Parse(ctx, inc)
+		if err != nil || pf.AST() == nil {
+			continue
+		}
+
+		incNames := make(map[string]struct{})
+		collectTypeNames(pf.AST(), incNames)
+
+		qual := includeNameOf(inc)
+		for name := range incNames {
+			show := qual + "." + name
+			res = append(res, Candidate{
+				showText:   show,
+				insertText: show,
+				format:     protocol.InsertTextFormatPlainText,
+			})
+		}
+	}
+
 	for _, kw := range typeKeywords {
 		res = append(res, Candidate{
 			showText:   kw.text,
diff --git a/lsp/source/slot_completion_test.go b/lsp/source/slot_completion_test.go
index 46dcad4..a6725d3 100644
--- a/lsp/source/slot_completion_test.go
+++ b/lsp/source/slot_completion_test.go
@@ -201,8 +201,9 @@ func TestCompletionSlotProviders(t *testing.T) {
 	typeCands := typeProvider{}.Candidates(ctx, ss, "file:///tmp/main.thrift", cc)
 	typeLabels := labelsOf(typeCands)
 	assert.Contains(t, typeLabels, "Gundam")
-	assert.Contains(t, typeLabels, "MobileSuit", "types from included files")
-	assert.Contains(t, typeLabels, "BayFull", "types from included files")
+	assert.Contains(t, typeLabels, "federation.gundam.MobileSuit", "types from included files are include-qualified")
+	assert.NotContains(t, typeLabels, "MobileSuit", "bare imported types do not resolve")
+	assert.Contains(t, typeLabels, "federation.gundam.BayFull", "types from included files are include-qualified")
 
 	fieldCands := fieldNameProvider{}.Candidates(ctx, ss, "file:///tmp/main.thrift", cc)
 	fieldLabels := labelsOf(fieldCands)
-- 
2.51.2