Simplify prefix typo detection to use full suggestFn

Instead of only correcting the first path segment for prefix typos,
use the full multi-segment suggestFn. This produces better suggestions
(e.g., ${bundl.nme} → ${bundle.name}) and removes dead code.

Co-authored-by: Isaac

Author: shreyas-goenka

bundle/config/mutator/resolve_variable_references.go

@@ -43,8 +43,10 @@ var defaultPrefixes = []string{
 	"variables",
 }
 
-var artifactPath = dyn.MustPathFromString("artifacts")
-var resourcesPath = dyn.MustPathFromString("resources")
+var (
+	artifactPath  = dyn.MustPathFromString("artifacts")
+	resourcesPath = dyn.MustPathFromString("resources")
+)
 
 type resolveVariableReferences struct {
 	prefixes    []string
@@ -259,25 +261,16 @@ func (m *resolveVariableReferences) resolveOnce(b *bundle.Bundle, prefixes []dyn
 					return dyn.InvalidValue, dynvar.ErrSkipResolution
 				}
 
-				// Check for prefix typos before skipping. If the first
-				// component is close to a valid prefix, emit a warning
-				// with a suggestion. The reference is left unresolved to
-				// avoid breaking existing behavior.
-				if len(path) > 0 {
-					firstKey := path[0].Key()
-					prefixNames := m.suggestPrefixNames(prefixes)
-					best, dist := closestMatch(firstKey, prefixNames)
-					if best != "" && dist > 0 {
-						corrected := make(dyn.Path, len(path))
-						copy(corrected, path)
-						corrected[0] = dyn.Key(best)
-						suggestion := rewriteToVarShorthand(corrected.String())
-						key := rewriteToVarShorthand(path.String())
-						diags = diags.Append(diag.Diagnostic{
-							Severity: diag.Warning,
-							Summary:  fmt.Sprintf("reference does not exist: ${%s}. Did you mean ${%s}?", key, suggestion),
-						})
-					}
+				// Check for prefix typos before skipping. Use the full
+				// suggestFn to correct all segments (not just the prefix).
+				// The reference is left unresolved to avoid breaking
+				// existing behavior.
+				key := rewriteToVarShorthand(path.String())
+				if suggestion := suggestFn(key); suggestion != "" {
+					diags = diags.Append(diag.Diagnostic{
+						Severity: diag.Warning,
+						Summary:  fmt.Sprintf("reference does not exist: ${%s}. Did you mean ${%s}?", key, suggestion),
+					})
 				}
 
 				return dyn.InvalidValue, dynvar.ErrSkipResolution

bundle/config/mutator/suggest.go

@@ -112,29 +112,6 @@ func rewriteToVarShorthand(key string) string {
 	return key
 }
 
-// suggestPrefixNames returns the list of prefix names used for suggestion
-// matching. This includes the resolution prefixes plus additional well-known
-// prefixes like "var" and "resources" that users commonly reference.
-func (m *resolveVariableReferences) suggestPrefixNames(prefixes []dyn.Path) []string {
-	seen := map[string]bool{}
-	var names []string
-	for _, p := range prefixes {
-		key := p[0].Key()
-		if !seen[key] {
-			seen[key] = true
-			names = append(names, key)
-		}
-	}
-	// Add well-known prefixes that may not be in the resolution set.
-	for _, extra := range []string{"var", "resources"} {
-		if !seen[extra] {
-			seen[extra] = true
-			names = append(names, extra)
-		}
-	}
-	return names
-}
-
 // makeSuggestFn builds a SuggestFn that uses Go type information and runtime
 // dyn values to generate suggestions for unresolved variable references.
 //

bundle/config/mutator/suggest_test.go

@@ -76,7 +76,7 @@ func TestStructFieldNames(t *testing.T) {
 
 	assert.Contains(t, names, "embedded_field")
 	assert.Contains(t, names, "name")
-	assert.Contains(t, names, "id")            // readonly should be included
+	assert.Contains(t, names, "id")                // readonly should be included
 	assert.NotContains(t, names, "internal_field") // internal should be excluded
 	assert.NotContains(t, names, "-")
 	assert.NotContains(t, names, "NoTag") // No json tag → excluded
@@ -109,9 +109,9 @@ func TestRewriteToVarShorthand(t *testing.T) {
 	}{
 		{"variables.my_cluster.value", "var.my_cluster"},
 		{"variables.x.value", "var.x"},
-		{"bundle.name", "bundle.name"},                           // not a variables path
-		{"variables.foo.bar.value", "variables.foo.bar.value"},   // nested - don't rewrite
-		{"variables.foo.default", "variables.foo.default"},       // not .value suffix
+		{"bundle.name", "bundle.name"},                         // not a variables path
+		{"variables.foo.bar.value", "variables.foo.bar.value"}, // nested - don't rewrite
+		{"variables.foo.default", "variables.foo.default"},     // not .value suffix
 	}
 	for _, tt := range tests {
 		assert.Equal(t, tt.want, rewriteToVarShorthand(tt.in), "in=%q", tt.in)