Simplify suggest.go: remove hasFieldName, use package-level varPath

Replace FindStructFieldByKeyType + hasFieldName fallback with
slices.Contains on the candidates list. Move varPath to a package-level
var and remove it from function signatures. Thread varPrefixCorrected
through suggestPath's initialHasFix param to eliminate the special case.

Co-authored-by: Isaac

Author: shreyas-goenka

bundle/config/mutator/resolve_variable_references.go

@@ -46,6 +46,7 @@ var defaultPrefixes = []string{
 var (
 	artifactPath  = dyn.MustPathFromString("artifacts")
 	resourcesPath = dyn.MustPathFromString("resources")
+	varPath       = dyn.NewPath(dyn.Key("var"))
 )
 
 type resolveVariableReferences struct {
@@ -149,15 +150,11 @@ func (m *resolveVariableReferences) Apply(ctx context.Context, b *bundle.Bundle)
 		prefixes[i] = dyn.MustPathFromString(prefix)
 	}
 
-	// The path ${var.foo} is a shorthand for ${variables.foo.value}.
-	// We rewrite it here to make the resolution logic simpler.
-	varPath := dyn.NewPath(dyn.Key("var"))
-
 	var diags diag.Diagnostics
 	maxRounds := 1 + m.extraRounds
 
 	for round := range maxRounds {
-		hasUpdates, newDiags := m.resolveOnce(b, prefixes, varPath)
+		hasUpdates, newDiags := m.resolveOnce(b, prefixes)
 
 		diags = diags.Extend(newDiags)
 
@@ -186,7 +183,7 @@ func (m *resolveVariableReferences) Apply(ctx context.Context, b *bundle.Bundle)
 	return diags
 }
 
-func (m *resolveVariableReferences) resolveOnce(b *bundle.Bundle, prefixes []dyn.Path, varPath dyn.Path) (bool, diag.Diagnostics) {
+func (m *resolveVariableReferences) resolveOnce(b *bundle.Bundle, prefixes []dyn.Path) (bool, diag.Diagnostics) {
 	var diags diag.Diagnostics
 	hasUpdates := false
 	err := m.selectivelyMutate(b, func(root dyn.Value) (dyn.Value, error) {
@@ -205,7 +202,7 @@ func (m *resolveVariableReferences) resolveOnce(b *bundle.Bundle, prefixes []dyn
 		//
 		normalized, _ := convert.Normalize(b.Config, root, convert.IncludeMissingFields)
 
-		suggestFn := m.makeSuggestFn(normalized, prefixes, varPath)
+		suggestFn := m.makeSuggestFn(normalized)
 
 		// If the pattern is nil, we resolve references in the entire configuration.
 		root, err := dyn.MapByPattern(root, m.pattern, func(p dyn.Path, v dyn.Value) (dyn.Value, error) {

bundle/config/mutator/suggest.go

@@ -3,6 +3,7 @@ package mutator
 import (
 	"math"
 	"reflect"
+	"slices"
 	"strings"
 
 	"github.com/databricks/cli/bundle/config"
@@ -125,19 +126,15 @@ func rewriteToVarShorthand(key string) string {
 //   - Map types: candidates come from the actual runtime dyn.Value keys.
 func (m *resolveVariableReferences) makeSuggestFn(
 	normalized dyn.Value,
-	prefixes []dyn.Path,
-	varPath dyn.Path,
 ) dynvar.SuggestFn {
 	return func(key string) string {
-		return m.suggest(key, normalized, prefixes, varPath)
+		return m.suggest(key, normalized)
 	}
 }
 
 func (m *resolveVariableReferences) suggest(
 	key string,
 	normalized dyn.Value,
-	prefixes []dyn.Path,
-	varPath dyn.Path,
 ) string {
 	// Parse the key into path segments.
 	path, err := dyn.NewPathFromString(key)
@@ -170,16 +167,7 @@ func (m *resolveVariableReferences) suggest(
 		segments[i] = c.Key()
 	}
 
-	suggestion := suggestPath(segments, normalized)
-
-	// If suggestPath found no deeper fixes but the var prefix itself was
-	// corrected, verify the rewritten path is valid and use it.
-	if suggestion == "" && varPrefixCorrected {
-		if _, err := dyn.GetByPath(normalized, path); err == nil {
-			suggestion = path.String()
-		}
-	}
-
+	suggestion := suggestPath(segments, normalized, varPrefixCorrected)
 	if suggestion == "" {
 		return ""
 	}
@@ -193,11 +181,11 @@ func (m *resolveVariableReferences) suggest(
 // suggestPath walks the config type tree and dyn value tree segment by segment,
 // greedily correcting each wrong segment. Returns the corrected dot-separated
 // path if any corrections were made, or "" if no suggestion can be produced.
-func suggestPath(segments []string, normalized dyn.Value) string {
+func suggestPath(segments []string, normalized dyn.Value, initialHasFix bool) string {
 	currentType := reflect.TypeOf(config.Root{})
 	currentDyn := normalized
 	corrected := make([]string, len(segments))
-	hasFix := false
+	hasFix := initialHasFix
 
 	for i, seg := range segments {
 		// Dereference pointer types.
@@ -216,18 +204,9 @@ func suggestPath(segments []string, normalized dyn.Value) string {
 		case reflect.Struct:
 			candidates = structFieldNames(currentType)
 
-			// Try exact match first.
-			sf, _, ok := structaccess.FindStructFieldByKeyType(currentType, seg)
-			if ok {
+			if slices.Contains(candidates, seg) {
 				corrected[i] = seg
-				nextType = sf.Type
-			} else {
-				// Exact match failed. Also check readonly fields that
-				// FindStructFieldByKeyType skips.
-				if hasFieldName(currentType, seg) {
-					corrected[i] = seg
-					nextType = fieldTypeByName(currentType, seg)
-				}
+				nextType = fieldTypeByName(currentType, seg)
 			}
 
 		case reflect.Map:
@@ -259,12 +238,7 @@ func suggestPath(segments []string, normalized dyn.Value) string {
 
 			// Advance type using the corrected segment.
 			if currentType.Kind() == reflect.Struct {
-				sf, _, ok := structaccess.FindStructFieldByKeyType(currentType, best)
-				if ok {
-					nextType = sf.Type
-				} else {
-					nextType = fieldTypeByName(currentType, best)
-				}
+				nextType = fieldTypeByName(currentType, best)
 			}
 			// For maps, nextType is already set to the map element type.
 		}
@@ -289,44 +263,8 @@ func suggestPath(segments []string, normalized dyn.Value) string {
 	return strings.Join(corrected, ".")
 }
 
-// hasFieldName checks if a struct type has a field with the given JSON name,
-// including readonly fields (which FindStructFieldByKeyType skips).
-func hasFieldName(t reflect.Type, name string) bool {
-	for t.Kind() == reflect.Pointer {
-		t = t.Elem()
-	}
-	if t.Kind() != reflect.Struct {
-		return false
-	}
-	for i := range t.NumField() {
-		sf := t.Field(i)
-		if sf.PkgPath != "" {
-			continue
-		}
-		if sf.Anonymous && sf.Tag.Get("json") == "" {
-			ft := sf.Type
-			for ft.Kind() == reflect.Pointer {
-				ft = ft.Elem()
-			}
-			if hasFieldName(ft, name) {
-				return true
-			}
-			continue
-		}
-		jsonName := structtag.JSONTag(sf.Tag.Get("json")).Name()
-		if jsonName == name {
-			btag := structtag.BundleTag(sf.Tag.Get("bundle"))
-			if btag.Internal() {
-				continue
-			}
-			return true
-		}
-	}
-	return false
-}
-
 // fieldTypeByName returns the reflect.Type of a struct field identified by its
-// JSON name, searching embedded structs. Includes readonly fields.
+// JSON name, searching embedded structs.
 func fieldTypeByName(t reflect.Type, name string) reflect.Type {
 	for t.Kind() == reflect.Pointer {
 		t = t.Elem()

bundle/config/mutator/suggest_test.go

@@ -126,7 +126,7 @@ func TestSuggestPathSingleSegmentFix(t *testing.T) {
 		}),
 	})
 
-	result := suggestPath([]string{"bundle", "nme"}, normalized)
+	result := suggestPath([]string{"bundle", "nme"}, normalized, false)
 	assert.Equal(t, "bundle.name", result)
 }
 
@@ -138,7 +138,7 @@ func TestSuggestPathMultiSegmentFix(t *testing.T) {
 		}),
 	})
 
-	result := suggestPath([]string{"bundl", "nme"}, normalized)
+	result := suggestPath([]string{"bundl", "nme"}, normalized, false)
 	assert.Equal(t, "bundle.name", result)
 }
 
@@ -150,7 +150,7 @@ func TestSuggestPathAllCorrect(t *testing.T) {
 	})
 
 	// All segments match exactly → no suggestion needed.
-	result := suggestPath([]string{"bundle", "name"}, normalized)
+	result := suggestPath([]string{"bundle", "name"}, normalized, false)
 	assert.Equal(t, "", result)
 }
 
@@ -162,7 +162,7 @@ func TestSuggestPathNoMatch(t *testing.T) {
 	})
 
 	// "zzzzz" is too far from any candidate.
-	result := suggestPath([]string{"bundle", "zzzzz"}, normalized)
+	result := suggestPath([]string{"bundle", "zzzzz"}, normalized, false)
 	assert.Equal(t, "", result)
 }
 
@@ -176,7 +176,7 @@ func TestSuggestPathMapKey(t *testing.T) {
 		}),
 	})
 
-	result := suggestPath([]string{"variables", "my_clster", "value"}, normalized)
+	result := suggestPath([]string{"variables", "my_clster", "value"}, normalized, false)
 	assert.Equal(t, "variables.my_cluster.value", result)
 }
 
@@ -194,7 +194,7 @@ func TestSuggestPathResourceField(t *testing.T) {
 		}),
 	})
 
-	result := suggestPath([]string{"resources", "jobs", "my_job", "nme"}, normalized)
+	result := suggestPath([]string{"resources", "jobs", "my_job", "nme"}, normalized, false)
 	assert.Equal(t, "resources.jobs.my_job.name", result)
 }
 
@@ -211,10 +211,7 @@ func TestSuggestVarRewriting(t *testing.T) {
 		prefixes: defaultPrefixes,
 	}
 
-	prefixes := []dyn.Path{dyn.MustPathFromString("variables")}
-	varPath := dyn.NewPath(dyn.Key("var"))
-
-	suggestion := m.suggest("var.my_clster_id", normalized, prefixes, varPath)
+	suggestion := m.suggest("var.my_clster_id", normalized)
 	require.Equal(t, "var.my_cluster_id", suggestion)
 }
 
@@ -231,17 +228,14 @@ func TestSuggestVarPrefixTypo(t *testing.T) {
 		prefixes: defaultPrefixes,
 	}
 
-	prefixes := []dyn.Path{dyn.MustPathFromString("variables")}
-	varPath := dyn.NewPath(dyn.Key("var"))
-
 	// Typo in var prefix only, variable name is correct.
-	assert.Equal(t, "var.my_cluster_id", m.suggest("vr.my_cluster_id", normalized, prefixes, varPath))
+	assert.Equal(t, "var.my_cluster_id", m.suggest("vr.my_cluster_id", normalized))
 
 	// Typo in var prefix AND variable name.
-	assert.Equal(t, "var.my_cluster_id", m.suggest("vr.my_clster_id", normalized, prefixes, varPath))
+	assert.Equal(t, "var.my_cluster_id", m.suggest("vr.my_clster_id", normalized))
 
 	// Var prefix typo but no matching variable.
-	assert.Equal(t, "", m.suggest("vr.nonexistent", normalized, prefixes, varPath))
+	assert.Equal(t, "", m.suggest("vr.nonexistent", normalized))
 }
 
 func TestSuggestNoSuggestionForCorrectPath(t *testing.T) {
@@ -257,9 +251,6 @@ func TestSuggestNoSuggestionForCorrectPath(t *testing.T) {
 		prefixes: defaultPrefixes,
 	}
 
-	prefixes := []dyn.Path{dyn.MustPathFromString("variables")}
-	varPath := dyn.NewPath(dyn.Key("var"))
-
-	suggestion := m.suggest("var.my_cluster_id", normalized, prefixes, varPath)
+	suggestion := m.suggest("var.my_cluster_id", normalized)
 	assert.Equal(t, "", suggestion)
 }