Only classify test-named functions as test nodes

mapDefTypeToNodeKind marked any declaration whose name started with the
language test prefix as a test node, so a production type TestConfig or a
function testimonialCard (prefix "test" + lowercase continuation) was
miscategorized, which then excluded it from dead-code analysis and
changed its search kind. Restrict the test check to function/method
declarations and require a word boundary after a bare-word prefix
(separator-terminated prefixes like "test_" already encode the boundary).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tae2089

internal/parse/treesitter/walker.go

@@ -656,24 +656,48 @@ func (w *Walker) inferEnclosingReceiver(defNode *sitter.Node, content []byte) st
 
 // mapDefTypeToNodeKind maps query definition labels to internal node kinds.
 // @intent keep language query captures aligned with graph node categorization
-// @domainRule declarations matching the configured test prefix become test nodes
+// @domainRule only function/method declarations whose name is a test name become test nodes;
+// types, classes, and interfaces are never tests even when their name starts with the prefix
 func (w *Walker) mapDefTypeToNodeKind(defType string, name string) model.NodeKind {
-	if w.spec.TestPrefix != "" && strings.HasPrefix(name, w.spec.TestPrefix) {
-		return model.NodeKindTest
-	}
-
 	switch defType {
 	case "class":
 		return model.NodeKindClass
 	case "interface", "type":
 		return model.NodeKindType
-	case "function", "method":
-		return model.NodeKindFunction
 	default:
+		if isTestName(name, w.spec.TestPrefix) {
+			return model.NodeKindTest
+		}
 		return model.NodeKindFunction
 	}
 }
 
+// isTestName reports whether name denotes a test given the language's test prefix.
+// @intent avoid misclassifying production symbols like testimonialCard or TestConfig as tests.
+// @domainRule a separator-terminated prefix (e.g. "test_") is a boundary on its own; a bare-word
+// prefix (e.g. "Test", "test", "TEST") must be followed by end-of-name or a non-lowercase character
+// so it does not swallow a longer lowercase word.
+func isTestName(name, prefix string) bool {
+	if prefix == "" || !strings.HasPrefix(name, prefix) {
+		return false
+	}
+	last := prefix[len(prefix)-1]
+	if !isASCIILetterOrDigit(last) {
+		return true
+	}
+	rest := name[len(prefix):]
+	if rest == "" {
+		return true
+	}
+	c := rest[0]
+	return c < 'a' || c > 'z'
+}
+
+// @intent classify ASCII identifier characters for test-prefix boundary detection.
+func isASCIILetterOrDigit(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+}
+
 // buildQualifiedName joins package, receiver, and declaration name into a stable identifier.
 // @intent generate graph keys that distinguish methods from package-level declarations
 func (w *Walker) buildQualifiedName(pkg, receiver, name string) string {

internal/parse/treesitter/walker_test.go

@@ -1681,6 +1681,58 @@ func TestAdd(t *testing.T) {}
 	}
 }
 
+func TestParseGo_TestPrefixDoesNotMisclassifyProductionDecls(t *testing.T) {
+	src := `package main
+
+type TestConfig struct{}
+
+func Testimony() {}
+
+func TestAdd(t *testing.T) {}
+`
+	w := NewWalker(GoSpec)
+	nodes, _, err := w.Parse("main_test.go", []byte(src))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	testNodes := filterByKind(nodes, model.NodeKindTest)
+	if len(testNodes) != 1 || testNodes[0].Name != "TestAdd" {
+		t.Fatalf("expected only TestAdd as a test node, got %+v", testNodes)
+	}
+	// TestConfig (a type) and Testimony (Test + lowercase 'i') must not be tests.
+	byName := map[string]model.NodeKind{}
+	for _, n := range nodes {
+		byName[n.Name] = n.Kind
+	}
+	if byName["TestConfig"] == model.NodeKindTest {
+		t.Errorf("TestConfig type must not be a test node")
+	}
+	if byName["Testimony"] == model.NodeKindTest {
+		t.Errorf("Testimony (lowercase continuation) must not be a test node")
+	}
+}
+
+func TestParseTypeScript_TestPrefixRequiresWordBoundary(t *testing.T) {
+	src := `function testimonialCard() {}
+function testLogin() {}
+`
+	w := NewWalker(TypeScriptSpec)
+	nodes, _, err := w.Parse("app.ts", []byte(src))
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	kinds := map[string]model.NodeKind{}
+	for _, n := range nodes {
+		kinds[n.Name] = n.Kind
+	}
+	if kinds["testimonialCard"] == model.NodeKindTest {
+		t.Errorf("testimonialCard must not be classified as a test")
+	}
+	if kinds["testLogin"] != model.NodeKindTest {
+		t.Errorf("testLogin should be classified as a test, got %v", kinds["testLogin"])
+	}
+}
+
 func TestParsePython_TestFunction(t *testing.T) {
 	src := `def test_add():
     assert 1 + 1 == 2