internal: remove tags from structpath.PathNode (#3626)

## Why
The PathNode represents path alone, not what it points to.

Stacked on top of #3620

Author: denik

bundle/direct/dresources/all_test.go

@@ -154,7 +154,7 @@ func testCRUD(t *testing.T, group string, adapter *Adapter, client *databricks.W
 	require.NoError(t, err)
 	require.NotNil(t, remappedState)
 
-	require.NoError(t, structwalk.Walk(newState, func(path *structpath.PathNode, val any) {
+	require.NoError(t, structwalk.Walk(newState, func(path *structpath.PathNode, val any, field *reflect.StructField) {
 		remoteValue, err := structaccess.Get(remappedState, dyn.MustPathFromString(path.DynPath()))
 		if err != nil {
 			t.Errorf("Failed to read %s from remapped remote state %#v", path.DynPath(), remappedState)
@@ -187,7 +187,7 @@ func testCRUD(t *testing.T, group string, adapter *Adapter, client *databricks.W
 func validateFields(t *testing.T, configType reflect.Type, fields map[string]deployplan.ActionType) {
 	validPaths := make(map[string]struct{})
 
-	err := structwalk.WalkType(configType, func(path *structpath.PathNode, typ reflect.Type) bool {
+	err := structwalk.WalkType(configType, func(path *structpath.PathNode, typ reflect.Type, field *reflect.StructField) bool {
 		validPaths[path.String()] = struct{}{}
 		return true // continue walking
 	})

bundle/internal/validation/enum.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/databricks/cli/bundle/config"
 	"github.com/databricks/cli/libs/structs/structpath"
+	"github.com/databricks/cli/libs/structs/structtag"
 	"github.com/databricks/cli/libs/structs/structwalk"
 )
 
@@ -109,15 +110,17 @@ func getEnumValues(typ reflect.Type) ([]string, error) {
 func extractEnumFields(typ reflect.Type) ([]EnumPatternInfo, error) {
 	fieldsByPattern := make(map[string][]string)
 
-	err := structwalk.WalkType(typ, func(path *structpath.PathNode, fieldType reflect.Type) bool {
+	err := structwalk.WalkType(typ, func(path *structpath.PathNode, fieldType reflect.Type, field *reflect.StructField) bool {
 		if path == nil {
 			return true
 		}
 
 		// Do not generate enum validation code for fields that are internal or readonly.
-		bundleTag := path.BundleTag()
-		if bundleTag.Internal() || bundleTag.ReadOnly() {
-			return false
+		if field != nil {
+			bundleTag := structtag.BundleTag(field.Tag.Get("bundle"))
+			if bundleTag.Internal() || bundleTag.ReadOnly() {
+				return false
+			}
 		}
 
 		// Check if this field type is an enum

bundle/internal/validation/required.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/databricks/cli/bundle/config"
 	"github.com/databricks/cli/libs/structs/structpath"
+	"github.com/databricks/cli/libs/structs/structtag"
 	"github.com/databricks/cli/libs/structs/structwalk"
 )
 
@@ -45,29 +46,30 @@ func formatSliceToString(values []string) string {
 func extractRequiredFields(typ reflect.Type) ([]RequiredPatternInfo, error) {
 	fieldsByPattern := make(map[string][]string)
 
-	err := structwalk.WalkType(typ, func(path *structpath.PathNode, _ reflect.Type) bool {
-		if path == nil {
+	err := structwalk.WalkType(typ, func(path *structpath.PathNode, _ reflect.Type, field *reflect.StructField) bool {
+		if path == nil || field == nil {
 			return true
 		}
 
 		// Do not generate required validation code for fields that are internal or readonly.
-		bundleTag := path.BundleTag()
+		bundleTag := structtag.BundleTag(field.Tag.Get("bundle"))
 		if bundleTag.Internal() || bundleTag.ReadOnly() {
 			return false
 		}
 
 		// The "omitempty" tag indicates the field is optional in bundle config.
-		if path.JSONTag().OmitEmpty() {
+		jsonTag := structtag.JSONTag(field.Tag.Get("json"))
+		if jsonTag.OmitEmpty() {
 			return true
 		}
 
-		field, ok := path.Field()
+		fieldName, ok := path.Field()
 		if !ok {
 			return true
 		}
 
 		parentPath := path.Parent().DynPath()
-		fieldsByPattern[parentPath] = append(fieldsByPattern[parentPath], field)
+		fieldsByPattern[parentPath] = append(fieldsByPattern[parentPath], fieldName)
 		return true
 	})
 

cmd/bundle/debug/refschema.go

@@ -54,7 +54,7 @@ func dumpRemoteSchemas(out io.Writer) error {
 		pathTypes := make(map[string]map[string]map[string]struct{})
 
 		collect := func(root reflect.Type, source string) error {
-			return structwalk.WalkType(root, func(path *structpath.PathNode, typ reflect.Type) bool {
+			return structwalk.WalkType(root, func(path *structpath.PathNode, typ reflect.Type, field *reflect.StructField) bool {
 				if path == nil {
 					return true
 				}

libs/structs/structdiff/diff.go

@@ -7,6 +7,7 @@ import (
 	"sort"
 
 	"github.com/databricks/cli/libs/structs/structpath"
+	"github.com/databricks/cli/libs/structs/structtag"
 )
 
 type Change struct {
@@ -130,7 +131,8 @@ func diffStruct(path *structpath.PathNode, s1, s2 reflect.Value, changes *[]Chan
 		zero2 := v2Field.IsZero()
 
 		if zero1 || zero2 {
-			if node.JSONTag().OmitEmpty() {
+			jsonTag := structtag.JSONTag(sf.Tag.Get("json"))
+			if jsonTag.OmitEmpty() {
 				if zero1 {
 					if !slices.Contains(forced1, sf.Name) {
 						v1Field = reflect.ValueOf(nil)

libs/structs/structpath/path.go

@@ -20,23 +20,13 @@ const (
 // PathNode represents a node in a path for struct diffing.
 // It can represent struct fields, map keys, or array/slice indices.
 type PathNode struct {
-	prev      *PathNode
-	jsonTag   structtag.JSONTag // For JSON key resolution
-	bundleTag structtag.BundleTag
-	key       string // Computed key (JSON key for structs, string key for maps, or Go field name for fallback)
+	prev *PathNode
+	key  string // Computed key (JSON key for structs, string key for maps, or Go field name for fallback)
 	// If index >= 0, the node specifies a slice/array index in index.
 	// If index < 0, this describes the type of node (see tagStruct and other consts above)
 	index int
 }
 
-func (p *PathNode) JSONTag() structtag.JSONTag {
-	return p.jsonTag
-}
-
-func (p *PathNode) BundleTag() structtag.BundleTag {
-	return p.bundleTag
-}
-
 func (p *PathNode) IsRoot() bool {
 	return p == nil
 }
@@ -116,19 +106,16 @@ func NewMapKey(prev *PathNode, key string) *PathNode {
 // The jsonTag is used for JSON key resolution, and fieldName is used as fallback.
 func NewStructField(prev *PathNode, tag reflect.StructTag, fieldName string) *PathNode {
 	jsonTag := structtag.JSONTag(tag.Get("json"))
-	bundleTag := structtag.BundleTag(tag.Get("bundle"))
 
 	key := fieldName
 	if name := jsonTag.Name(); name != "" {
 		key = name
 	}
 
 	return &PathNode{
-		prev:      prev,
-		jsonTag:   jsonTag,
-		bundleTag: bundleTag,
-		key:       key,
-		index:     tagStruct,
+		prev:  prev,
+		key:   key,
+		index: tagStruct,
 	}
 }
 

libs/structs/structwalk/walk.go

@@ -7,13 +7,15 @@ import (
 	"sort"
 
 	"github.com/databricks/cli/libs/structs/structpath"
+	"github.com/databricks/cli/libs/structs/structtag"
 )
 
 // VisitFunc is invoked for every scalar (int, uint, float, string, bool) field encountered while walking v.
 //
 //   path         PathNode representing the JSON-style path to the field.
 //   val          the field's value – if the field is a pointer to a scalar the pointer is *not* dereferenced; the
 //                callback receives either nil (for a nil pointer) or the concrete value.
+//   field        the reflect.StructField for struct fields, nil for map keys and array indices.
 //
 // NOTE: Fields lacking a json tag or tagged as "-" are ignored entirely.
 //       Composite kinds (struct, slice/array, map, interface, function, chan, etc.) are *not* visited, but the walk
@@ -23,13 +25,13 @@ import (
 // The walk is depth-first and deterministic (map keys are sorted lexicographically).
 //
 // Example:
-//   err := structwalk.Walk(cfg, func(path *structpath.PathNode, v any) {
+//   err := structwalk.Walk(cfg, func(path *structpath.PathNode, v any, field *reflect.StructField) {
 //       fmt.Printf("%s = %v\n", path.String(), v)
 //   })
 //
 // ******************************************************************************************************
 
-type VisitFunc func(path *structpath.PathNode, val any)
+type VisitFunc func(path *structpath.PathNode, val any, field *reflect.StructField)
 
 // Walk validates that v is a struct or pointer to one and starts the recursive traversal.
 func Walk(v any, visit VisitFunc) error {
@@ -40,7 +42,7 @@ func Walk(v any, visit VisitFunc) error {
 	if !rv.IsValid() {
 		return nil
 	}
-	walkValue(nil, rv, visit)
+	walkValue(nil, rv, nil, visit)
 	return nil
 }
 
@@ -58,25 +60,25 @@ func isScalar(k reflect.Kind) bool {
 	}
 }
 
-func walkValue(path *structpath.PathNode, val reflect.Value, visit VisitFunc) {
+func walkValue(path *structpath.PathNode, val reflect.Value, field *reflect.StructField, visit VisitFunc) {
 	kind := val.Kind()
 
 	if isScalar(kind) {
-		visit(path, val.Interface())
+		visit(path, val.Interface(), field)
 		return
 	}
 
 	switch kind {
 	case reflect.Pointer:
-		walkValue(path, val.Elem(), visit)
+		walkValue(path, val.Elem(), field, visit)
 
 	case reflect.Struct:
 		walkStruct(path, val, visit)
 
 	case reflect.Slice, reflect.Array:
 		for i := range val.Len() {
 			node := structpath.NewIndex(path, i)
-			walkValue(node, val.Index(i), visit)
+			walkValue(node, val.Index(i), nil, visit)
 		}
 
 	case reflect.Map:
@@ -91,7 +93,7 @@ func walkValue(path *structpath.PathNode, val reflect.Value, visit VisitFunc) {
 		for _, ks := range keys {
 			v := val.MapIndex(reflect.ValueOf(ks))
 			node := structpath.NewMapKey(path, ks)
-			walkValue(node, v, visit)
+			walkValue(node, v, nil, visit)
 		}
 
 	default:
@@ -114,17 +116,18 @@ func walkStruct(path *structpath.PathNode, s reflect.Value, visit VisitFunc) {
 		}
 
 		node := structpath.NewStructField(path, sf.Tag, sf.Name)
-		if node.JSONTag().Name() == "-" {
+		jsonTag := structtag.JSONTag(sf.Tag.Get("json"))
+		if jsonTag.Name() == "-" {
 			continue // skip fields without json name
 		}
 
 		fieldVal := s.Field(i)
 		// Skip zero values with omitempty unless field is explicitly forced.
-		if node.JSONTag().OmitEmpty() && fieldVal.IsZero() && !slices.Contains(forced, sf.Name) {
+		if jsonTag.OmitEmpty() && fieldVal.IsZero() && !slices.Contains(forced, sf.Name) {
 			continue
 		}
 
-		walkValue(node, fieldVal, visit)
+		walkValue(node, fieldVal, &sf, visit)
 	}
 }
 

libs/structs/structwalk/walk_test.go

@@ -1,25 +1,27 @@
 package structwalk
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/databricks/cli/libs/structs/structpath"
+	"github.com/databricks/cli/libs/structs/structtag"
 	"github.com/databricks/databricks-sdk-go/service/jobs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func flatten(t *testing.T, value any) map[string]any {
 	results := make(map[string]any)
-	err := Walk(value, func(path *structpath.PathNode, value any) {
+	err := Walk(value, func(path *structpath.PathNode, value any, field *reflect.StructField) {
 		s := path.String()
 		results[s] = value
 
 		// Test path parsing round trip
 		newPath, err := structpath.Parse(s)
 		if assert.NoError(t, err, s) {
-			// newPath is not comparable with path a.t.m due to bundle tags on PathNode
 			newS := newPath.String()
+			assert.Equal(t, path, newPath, "s=%q newS=%q", s, newS)
 			assert.Equal(t, s, newS)
 		}
 	})
@@ -107,11 +109,16 @@ func TestValueBundleTag(t *testing.T) {
 		B: "b",
 		C: "c",
 		D: "d",
-	}, func(path *structpath.PathNode, value any) {
-		if path.BundleTag().ReadOnly() {
+	}, func(path *structpath.PathNode, value any, field *reflect.StructField) {
+		if field == nil {
+			return
+		}
+
+		bundleTag := structtag.BundleTag(field.Tag.Get("bundle"))
+		if bundleTag.ReadOnly() {
 			readonly = append(readonly, path.String())
 		}
-		if path.BundleTag().Internal() {
+		if bundleTag.Internal() {
 			internal = append(internal, path.String())
 		}
 	})