grindlemire/go-tui code browser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488

package lsp

import (
	"encoding/json"
	"testing"

	"github.com/grindlemire/go-tui/internal/lsp/provider"
)

func TestCommentSemanticTokens(t *testing.T) {
	type tc struct {
		content     string
		wantTokens  int  // minimum number of comment tokens expected
		checkTokens bool // if true, verify specific token positions
	}

	tests := map[string]tc{
		"line comment before component": {
			content: `package main

// This is a comment
templ Hello() {
	<span>Hello</span>
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
		"trailing comment on component": {
			content: `package main

templ Hello() {  // trailing comment
	<span>Hello</span>
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
		"block comment": {
			content: `package main

/* Block comment */
templ Hello() {
	<span>Hello</span>
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
		"comment inside element": {
			content: `package main

templ Hello() {
	// comment inside body
	<span>Hello</span>
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
		"multiple comments": {
			content: `package main

// Comment 1
// Comment 2
templ Hello() {
	// Comment 3
	<span>Hello</span>  // Comment 4
}
`,
			wantTokens:  4,
			checkTokens: true,
		},
		"comment in if statement": {
			content: `package main

templ Hello(show bool) {
	// comment before if
	if show {
		<span>Hello</span>
	}
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
		"comment in for loop": {
			content: `package main

templ List(items []string) {
	// comment before for
	for _, item := range items {
		<span>{item}</span>
	}
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
		"orphan comment in component body": {
			content: `package main

templ Hello() {
	// orphan comment with no following node
}
`,
			wantTokens:  1,
			checkTokens: true,
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			server := NewServer(nil, nil)

			doc := server.docs.Open("file:///test.gsx", tt.content, 1)
			server.index.IndexDocument("file:///test.gsx", doc.AST)

			params, _ := json.Marshal(SemanticTokensParams{
				TextDocument: TextDocumentIdentifier{URI: "file:///test.gsx"},
			})

			result, rpcErr := server.router.Route(Request{
				Method: "textDocument/semanticTokens/full",
				Params: params,
			})

			if rpcErr != nil {
				t.Fatalf("semantic tokens error: %v", rpcErr)
			}

			tokens, ok := result.(*SemanticTokens)
			if !ok {
				t.Fatalf("expected *SemanticTokens, got %T", result)
			}

			// Count comment tokens (every 5th value starting at index 3 is the token type)
			commentCount := countTokensByType(tokens.Data, provider.TokenTypeComment)

			if commentCount < tt.wantTokens {
				t.Errorf("got %d comment tokens, want at least %d", commentCount, tt.wantTokens)
			}
		})
	}
}

func TestCommentTokenPositions(t *testing.T) {
	type tc struct {
		content        string
		expectedLine   int // 0-indexed
		expectedCol    int // 0-indexed
		expectedLength int
	}

	tests := map[string]tc{
		"line comment position": {
			content: `package main

// Hello
templ Hello() {
	<span>Hello</span>
}
`,
			expectedLine:   2, // 0-indexed, line 3 in 1-indexed
			expectedCol:    0,
			expectedLength: 8, // "// Hello"
		},
		"indented comment position": {
			content: `package main

templ Hello() {
	// indented comment
	<span>Hello</span>
}
`,
			expectedLine:   3, // 0-indexed
			expectedCol:    1, // after tab
			expectedLength: 19,
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			server := NewServer(nil, nil)

			doc := server.docs.Open("file:///test.gsx", tt.content, 1)
			server.index.IndexDocument("file:///test.gsx", doc.AST)

			params, _ := json.Marshal(SemanticTokensParams{
				TextDocument: TextDocumentIdentifier{URI: "file:///test.gsx"},
			})

			result, rpcErr := server.router.Route(Request{
				Method: "textDocument/semanticTokens/full",
				Params: params,
			})

			if rpcErr != nil {
				t.Fatalf("semantic tokens error: %v", rpcErr)
			}

			tokens, ok := result.(*SemanticTokens)
			if !ok {
				t.Fatalf("expected *SemanticTokens, got %T", result)
			}

			// Decode delta-encoded tokens to find the first comment token
			decoded := decodeSemanticTokens(tokens.Data)
			var foundComment *decodedToken
			for i := range decoded {
				if decoded[i].tokenType == provider.TokenTypeComment {
					foundComment = &decoded[i]
					break
				}
			}

			if foundComment == nil {
				t.Fatal("expected to find a comment token")
			}

			if foundComment.line != tt.expectedLine {
				t.Errorf("comment token line = %d, want %d", foundComment.line, tt.expectedLine)
			}

			if foundComment.startChar != tt.expectedCol {
				t.Errorf("comment token startChar = %d, want %d", foundComment.startChar, tt.expectedCol)
			}

			if foundComment.length != tt.expectedLength {
				t.Errorf("comment token length = %d, want %d", foundComment.length, tt.expectedLength)
			}
		})
	}
}

func TestBlockCommentTokens(t *testing.T) {
	type tc struct {
		content    string
		wantTokens int // number of tokens for the block comment (one per line)
	}

	tests := map[string]tc{
		"single line block comment": {
			content: `package main

/* single line */
templ Hello() {
	<span>Hello</span>
}
`,
			wantTokens: 1,
		},
		"multi-line block comment": {
			content: `package main

/* line 1
   line 2
   line 3 */
templ Hello() {
	<span>Hello</span>
}
`,
			wantTokens: 3, // one token per line
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			server := NewServer(nil, nil)

			doc := server.docs.Open("file:///test.gsx", tt.content, 1)
			server.index.IndexDocument("file:///test.gsx", doc.AST)

			params, _ := json.Marshal(SemanticTokensParams{
				TextDocument: TextDocumentIdentifier{URI: "file:///test.gsx"},
			})

			result, rpcErr := server.router.Route(Request{
				Method: "textDocument/semanticTokens/full",
				Params: params,
			})

			if rpcErr != nil {
				t.Fatalf("semantic tokens error: %v", rpcErr)
			}

			tokens, ok := result.(*SemanticTokens)
			if !ok {
				t.Fatalf("expected *SemanticTokens, got %T", result)
			}

			commentCount := countTokensByType(tokens.Data, provider.TokenTypeComment)

			if commentCount != tt.wantTokens {
				t.Errorf("got %d comment tokens, want %d", commentCount, tt.wantTokens)
			}
		})
	}
}

func TestInlineBlockCommentInGoExpr(t *testing.T) {
	// Test that inline block comments inside Go expressions are properly tokenized
	type tc struct {
		content string
	}

	tests := map[string]tc{
		"inline block comment in sprintf": {
			content: `package main

import "fmt"

templ Hello(item string) {
	<span>{fmt.Sprintf("> %s", /* ItemList item */ item)}</span>
}
`,
		},
		"inline block comment in simple expression": {
			content: `package main

templ Hello(x int) {
	<span>{/* test */ x}</span>
}
`,
		},
	}

	for name, tt := range tests {
		t.Run(name, func(t *testing.T) {
			server := NewServer(nil, nil)

			doc := server.docs.Open("file:///test.gsx", tt.content, 1)
			server.index.IndexDocument("file:///test.gsx", doc.AST)

			params, _ := json.Marshal(SemanticTokensParams{
				TextDocument: TextDocumentIdentifier{URI: "file:///test.gsx"},
			})

			result, rpcErr := server.router.Route(Request{
				Method: "textDocument/semanticTokens/full",
				Params: params,
			})

			if rpcErr != nil {
				t.Fatalf("semantic tokens error: %v", rpcErr)
			}

			tokens, ok := result.(*SemanticTokens)
			if !ok {
				t.Fatalf("expected *SemanticTokens, got %T", result)
			}

			// Decode and find comment tokens
			decoded := decodeSemanticTokens(tokens.Data)
			var foundComment *decodedToken
			for i := range decoded {
				if decoded[i].tokenType == provider.TokenTypeComment {
					foundComment = &decoded[i]
					break
				}
			}

			if foundComment == nil {
				t.Fatalf("expected to find a comment token for inline block comment")
			}

			// Just verify we found a comment token - the actual highlighting will work
			t.Logf("Found comment token: line=%d startChar=%d length=%d",
				foundComment.line, foundComment.startChar, foundComment.length)
		})
	}
}

func TestCommentsInVariousPositions(t *testing.T) {
	// Test that comments are collected from all supported positions
	content := `package main

// File leading comment

// Component doc comment
templ Hello(name string) {  // Component trailing
	// Element leading
	<div>  // Element trailing
		// Nested comment
		<span>{name}</span>
	</div>
}

// Function comment
func helper() string {
	return "test"
}
`
	server := NewServer(nil, nil)

	doc := server.docs.Open("file:///test.gsx", content, 1)
	server.index.IndexDocument("file:///test.gsx", doc.AST)

	params, _ := json.Marshal(SemanticTokensParams{
		TextDocument: TextDocumentIdentifier{URI: "file:///test.gsx"},
	})

	result, rpcErr := server.router.Route(Request{
		Method: "textDocument/semanticTokens/full",
		Params: params,
	})

	if rpcErr != nil {
		t.Fatalf("semantic tokens error: %v", rpcErr)
	}

	tokens, ok := result.(*SemanticTokens)
	if !ok {
		t.Fatalf("expected *SemanticTokens, got %T", result)
	}

	commentCount := countTokensByType(tokens.Data, provider.TokenTypeComment)

	// We expect at least 7 comments:
	// 1. File leading
	// 2. Component doc
	// 3. Component trailing
	// 4. Element leading
	// 5. Element trailing
	// 6. Nested comment
	// 7. Function comment
	expectedMin := 7
	if commentCount < expectedMin {
		t.Errorf("got %d comment tokens, want at least %d", commentCount, expectedMin)
	}
}

// --- Test helpers ---

// decodedToken represents a semantic token decoded from LSP delta format.
type decodedToken struct {
	line      int
	startChar int
	length    int
	tokenType int
	modifiers int
}

// countTokensByType counts tokens of a given type in LSP delta-encoded data.
func countTokensByType(data []int, tokenType int) int {
	count := 0
	for i := 3; i < len(data); i += 5 {
		if data[i] == tokenType {
			count++
		}
	}
	return count
}

// decodeSemanticTokens decodes LSP delta-encoded semantic token data into
// absolute positions.
func decodeSemanticTokens(data []int) []decodedToken {
	var tokens []decodedToken
	prevLine := 0
	prevChar := 0

	for i := 0; i+4 < len(data); i += 5 {
		deltaLine := data[i]
		deltaChar := data[i+1]
		length := data[i+2]
		tokenType := data[i+3]
		modifiers := data[i+4]

		line := prevLine + deltaLine
		startChar := deltaChar
		if deltaLine == 0 {
			startChar = prevChar + deltaChar
		}

		tokens = append(tokens, decodedToken{
			line:      line,
			startChar: startChar,
			length:    length,
			tokenType: tokenType,
			modifiers: modifiers,
		})

		prevLine = line
		prevChar = startChar
	}

	return tokens
}