🔍 refactor(definition): support qualified names and trim trailing () in symbol matching

- Accept queries like Class.method or ns::Class.method by matching containerName and member
- Trim trailing parentheses in queries (e.g. foo())
- Preserve previous behavior for unqualified names and other servers

Author: LaelLuo

internal/tools/definition.go

@@ -10,9 +10,15 @@ import (
 )
 
 func ReadDefinition(ctx context.Context, client *lsp.Client, symbolName string) (string, error) {
-	symbolResult, err := client.Symbol(ctx, protocol.WorkspaceSymbolParams{
-		Query: symbolName,
-	})
+    // Normalize common user inputs, e.g. "foo()" -> "foo"
+    normalized := strings.TrimSpace(symbolName)
+    if strings.HasSuffix(normalized, "()") {
+        normalized = strings.TrimSuffix(normalized, "()")
+    }
+
+    symbolResult, err := client.Symbol(ctx, protocol.WorkspaceSymbolParams{
+        Query: normalized,
+    })
 	if err != nil {
 		return "", fmt.Errorf("failed to fetch symbol: %v", err)
 	}
@@ -23,43 +29,84 @@ func ReadDefinition(ctx context.Context, client *lsp.Client, symbolName string)
 	}
 
 	var definitions []string
-	for _, symbol := range results {
-		kind := ""
-		container := ""
-
-		// Skip symbols that we are not looking for. workspace/symbol may return
-		// a large number of fuzzy matches.
-		switch v := symbol.(type) {
-		case *protocol.SymbolInformation:
-			// SymbolInformation results have richer data.
-			kind = fmt.Sprintf("Kind: %s\n", protocol.TableKindMap[v.Kind])
-			if v.ContainerName != "" {
-				container = fmt.Sprintf("Container Name: %s\n", v.ContainerName)
-			}
-
-			// Handle different matching strategies based on the search term
-			if strings.Contains(symbolName, ".") {
-				// For qualified names like "Type.Method", require exact match
-				if symbol.GetName() != symbolName {
-					continue
-				}
-			} else {
-				// For unqualified names like "Method"
-				if v.Kind == protocol.Method {
-					// For methods, only match if the method name matches exactly Type.symbolName or Type::symbolName or symbolName
-					if !strings.HasSuffix(symbol.GetName(), "::"+symbolName) && !strings.HasSuffix(symbol.GetName(), "."+symbolName) && symbol.GetName() != symbolName {
-						continue
-					}
-				} else if symbol.GetName() != symbolName {
-					// For non-methods, exact match only
-					continue
-				}
-			}
-		default:
-			if symbol.GetName() != symbolName {
-				continue
-			}
-		}
+    // Determine if the query is qualified (e.g., Class.method or ns::Class)
+    isQualified := strings.Contains(normalized, ".") || strings.Contains(normalized, "::")
+    // Extract container and member parts if qualified
+    containerWanted := ""
+    memberWanted := normalized
+    if isQualified {
+        // Split on last occurrence of '.' or '::'
+        // Prefer the right-most separator to support nested containers
+        if idx := strings.LastIndex(normalized, "::"); idx != -1 {
+            containerWanted = normalized[:idx]
+            memberWanted = normalized[idx+2:]
+        } else if idx := strings.LastIndex(normalized, "."); idx != -1 {
+            containerWanted = normalized[:idx]
+            memberWanted = normalized[idx+1:]
+        }
+    }
+
+    for _, symbol := range results {
+        kind := ""
+        container := ""
+
+        // Skip symbols that we are not looking for. workspace/symbol may return
+        // a large number of fuzzy matches.
+        switch v := symbol.(type) {
+        case *protocol.SymbolInformation:
+            // SymbolInformation results have richer data.
+            kind = fmt.Sprintf("Kind: %s\n", protocol.TableKindMap[v.Kind])
+            if v.ContainerName != "" {
+                container = fmt.Sprintf("Container Name: %s\n", v.ContainerName)
+            }
+
+            // Matching strategy
+            name := symbol.GetName()
+            if isQualified {
+                // Qualified lookup
+                // Accept if:
+                // - name equals memberWanted; and, if we know the container, it matches containerWanted (exact or suffix)
+                // - or name equals the full normalized string (some servers include container in name)
+                if name != memberWanted && name != normalized && !strings.HasSuffix(name, "::"+memberWanted) && !strings.HasSuffix(name, "."+memberWanted) {
+                    continue
+                }
+                if containerWanted != "" && v.ContainerName != "" {
+                    // containerName may be only the immediate container. Allow suffix match to tolerate nesting
+                    if v.ContainerName != containerWanted &&
+                        !strings.HasSuffix(v.ContainerName, "."+containerWanted) &&
+                        !strings.HasSuffix(v.ContainerName, "::"+containerWanted) &&
+                        !strings.HasSuffix(containerWanted, "."+v.ContainerName) &&
+                        !strings.HasSuffix(containerWanted, "::"+v.ContainerName) {
+                        continue
+                    }
+                }
+            } else {
+                // Unqualified lookup
+                if name != normalized {
+                    // For methods, also allow suffix match like *.method
+                    if v.Kind == protocol.Method {
+                        if !strings.HasSuffix(name, "."+normalized) && !strings.HasSuffix(name, "::"+normalized) {
+                            continue
+                        }
+                    } else {
+                        continue
+                    }
+                }
+            }
+        default:
+            if !isQualified {
+                if symbol.GetName() != normalized {
+                    continue
+                }
+            } else {
+                // For unknown result types, require exact match with full normalized string
+                if symbol.GetName() != normalized &&
+                    !strings.HasSuffix(symbol.GetName(), "."+memberWanted) &&
+                    !strings.HasSuffix(symbol.GetName(), "::"+memberWanted) {
+                    continue
+                }
+            }
+        }
 
 		toolsLogger.Debug("Found symbol: %s", symbol.GetName())
 		loc := symbol.GetLocation()