Merge pull request kubernetes#130699 from thockin/master_validation-gen_odd_cases

Prevent validation-gen usage patterns we don't want to support

Author: k8s-ci-robot

staging/src/k8s.io/apimachinery/pkg/api/validate/each.go

@@ -43,26 +43,6 @@ func EachSliceVal[T any](ctx context.Context, op operation.Operation, fldPath *f
 	return errs
 }
 
-// EachSliceValNilable validates each element of newSlice with the specified
-// validation function.  The comparison function is used to find the
-// corresponding value in oldSlice.  The value-type of the slices is assumed to
-// be nilable.
-func EachSliceValNilable[T any](ctx context.Context, op operation.Operation, fldPath *field.Path, newSlice, oldSlice []T,
-	cmp CompareFunc[T], validator ValidateFunc[T]) field.ErrorList {
-	var errs field.ErrorList
-	for i, val := range newSlice {
-		var old T
-		if cmp != nil && len(oldSlice) > 0 {
-			p := lookup(oldSlice, val, cmp)
-			if p != nil {
-				old = *p
-			}
-		}
-		errs = append(errs, validator(ctx, op, fldPath.Index(i), val, old)...)
-	}
-	return errs
-}
-
 // lookup returns a pointer to the first element in the list that matches the
 // target, according to the provided comparison function, or else nil.
 func lookup[T any](list []T, target T, cmp func(T, T) bool) *T {
@@ -90,22 +70,6 @@ func EachMapVal[K ~string, V any](ctx context.Context, op operation.Operation, f
 	return errs
 }
 
-// EachMapValNilable validates each element of newMap with the specified
-// validation function and, if the corresponding key is found in oldMap, the
-// old value. The value-type of the slices is assumed to be nilable.
-func EachMapValNilable[K ~string, V any](ctx context.Context, op operation.Operation, fldPath *field.Path, newMap, oldMap map[K]V,
-	validator ValidateFunc[V]) field.ErrorList {
-	var errs field.ErrorList
-	for key, val := range newMap {
-		var old V
-		if o, found := oldMap[key]; found {
-			old = o
-		}
-		errs = append(errs, validator(ctx, op, fldPath.Key(string(key)), val, old)...)
-	}
-	return errs
-}
-
 // EachMapKey validates each element of newMap with the specified
 // validation function.  The oldMap argument is not used.
 func EachMapKey[K ~string, T any](ctx context.Context, op operation.Operation, fldPath *field.Path, newMap, oldMap map[K]T,

staging/src/k8s.io/apimachinery/pkg/api/validate/each_test.go

@@ -25,7 +25,6 @@ import (
 
 	"k8s.io/apimachinery/pkg/api/operation"
 	"k8s.io/apimachinery/pkg/util/validation/field"
-	"k8s.io/utils/ptr"
 )
 
 type TestStruct struct {
@@ -102,107 +101,6 @@ func testEachSliceValUpdate[T any](t *testing.T, name string, input []T) {
 	})
 }
 
-func TestEachSliceValNilablePointer(t *testing.T) {
-	testEachSliceValNilable(t, "valid", []*int{ptr.To(11), ptr.To(12), ptr.To(13)})
-	testEachSliceValNilable(t, "valid", []*string{ptr.To("a"), ptr.To("b"), ptr.To("c")})
-	testEachSliceValNilable(t, "valid", []*TestStruct{{11, "a"}, {12, "b"}, {13, "c"}})
-
-	testEachSliceValNilable(t, "empty", []*int{})
-	testEachSliceValNilable(t, "empty", []*string{})
-	testEachSliceValNilable(t, "empty", []*TestStruct{})
-
-	testEachSliceValNilable[int](t, "nil", nil)
-	testEachSliceValNilable[string](t, "nil", nil)
-	testEachSliceValNilable[TestStruct](t, "nil", nil)
-
-	testEachSliceValNilableUpdate(t, "valid", []*int{ptr.To(11), ptr.To(12), ptr.To(13)})
-	testEachSliceValNilableUpdate(t, "valid", []*string{ptr.To("a"), ptr.To("b"), ptr.To("c")})
-	testEachSliceValNilableUpdate(t, "valid", []*TestStruct{{11, "a"}, {12, "b"}, {13, "c"}})
-
-	testEachSliceValNilableUpdate(t, "empty", []*int{})
-	testEachSliceValNilableUpdate(t, "empty", []*string{})
-	testEachSliceValNilableUpdate(t, "empty", []*TestStruct{})
-
-	testEachSliceValNilableUpdate[int](t, "nil", nil)
-	testEachSliceValNilableUpdate[string](t, "nil", nil)
-	testEachSliceValNilableUpdate[TestStruct](t, "nil", nil)
-}
-
-func TestEachSliceValNilableSlice(t *testing.T) {
-	testEachSliceValNilable(t, "valid", [][]int{{11, 12, 13}, {12, 13, 14}, {13, 14, 15}})
-	testEachSliceValNilable(t, "valid", [][]string{{"a", "b", "c"}, {"b", "c", "d"}, {"c", "d", "e"}})
-	testEachSliceValNilable(t, "valid", [][]TestStruct{
-		{{11, "a"}, {12, "b"}, {13, "c"}},
-		{{12, "a"}, {13, "b"}, {14, "c"}},
-		{{13, "a"}, {14, "b"}, {15, "c"}}})
-
-	testEachSliceValNilable(t, "empty", [][]int{{}, {}, {}})
-	testEachSliceValNilable(t, "empty", [][]string{{}, {}, {}})
-	testEachSliceValNilable(t, "empty", [][]TestStruct{{}, {}, {}})
-
-	testEachSliceValNilable[int](t, "nil", nil)
-	testEachSliceValNilable[string](t, "nil", nil)
-	testEachSliceValNilable[TestStruct](t, "nil", nil)
-
-	testEachSliceValNilableUpdate(t, "valid", [][]int{{11, 12, 13}, {12, 13, 14}, {13, 14, 15}})
-	testEachSliceValNilableUpdate(t, "valid", [][]string{{"a", "b", "c"}, {"b", "c", "d"}, {"c", "d", "e"}})
-	testEachSliceValNilableUpdate(t, "valid", [][]TestStruct{
-		{{11, "a"}, {12, "b"}, {13, "c"}},
-		{{12, "a"}, {13, "b"}, {14, "c"}},
-		{{13, "a"}, {14, "b"}, {15, "c"}}})
-
-	testEachSliceValNilableUpdate(t, "empty", [][]int{{}, {}, {}})
-	testEachSliceValNilableUpdate(t, "empty", [][]string{{}, {}, {}})
-	testEachSliceValNilableUpdate(t, "empty", [][]TestStruct{{}, {}, {}})
-
-	testEachSliceValNilableUpdate[int](t, "nil", nil)
-	testEachSliceValNilableUpdate[string](t, "nil", nil)
-	testEachSliceValNilableUpdate[TestStruct](t, "nil", nil)
-}
-
-func testEachSliceValNilable[T any](t *testing.T, name string, input []T) {
-	var zero T
-	t.Run(fmt.Sprintf("%s(%T)", name, zero), func(t *testing.T) {
-		calls := 0
-		vfn := func(ctx context.Context, op operation.Operation, fldPath *field.Path, newVal, oldVal T) field.ErrorList {
-			if !reflect.DeepEqual(oldVal, zero) {
-				t.Errorf("expected nil oldVal, got %v", oldVal)
-			}
-			calls++
-			return nil
-		}
-		_ = EachSliceValNilable(context.Background(), operation.Operation{}, field.NewPath("test"), input, nil, nil, vfn)
-		if calls != len(input) {
-			t.Errorf("expected %d calls, got %d", len(input), calls)
-		}
-	})
-}
-
-func testEachSliceValNilableUpdate[T any](t *testing.T, name string, input []T) {
-	var zero T
-	t.Run(fmt.Sprintf("%s(%T)", name, zero), func(t *testing.T) {
-		calls := 0
-		vfn := func(ctx context.Context, op operation.Operation, fldPath *field.Path, newVal, oldVal T) field.ErrorList {
-			if reflect.DeepEqual(oldVal, zero) {
-				t.Fatalf("expected non-nil oldVal")
-			}
-			if !reflect.DeepEqual(newVal, oldVal) {
-				t.Errorf("expected oldVal == newVal, got %v, %v", oldVal, newVal)
-			}
-			calls++
-			return nil
-		}
-		old := make([]T, len(input))
-		copy(old, input)
-		slices.Reverse(old)
-		cmp := func(a, b T) bool { return reflect.DeepEqual(a, b) }
-		_ = EachSliceValNilable(context.Background(), operation.Operation{}, field.NewPath("test"), input, old, cmp, vfn)
-		if calls != len(input) {
-			t.Errorf("expected %d calls, got %d", len(input), calls)
-		}
-	})
-}
-
 func TestEachMapVal(t *testing.T) {
 	testEachMapVal(t, "valid", map[string]int{"one": 11, "two": 12, "three": 13})
 	testEachMapVal(t, "valid", map[string]string{"A": "a", "B": "b", "C": "c"})
@@ -235,61 +133,6 @@ func testEachMapVal[T any](t *testing.T, name string, input map[string]T) {
 	})
 }
 
-func TestEachMapValNilablePointer(t *testing.T) {
-	testEachMapValNilable(t, "valid", map[string]*int{"one": ptr.To(11), "two": ptr.To(12), "three": ptr.To(13)})
-	testEachMapValNilable(t, "valid", map[string]*string{"A": ptr.To("a"), "B": ptr.To("b"), "C": ptr.To("c")})
-	testEachMapValNilable(t, "valid", map[string]*TestStruct{"one": {11, "a"}, "two": {12, "b"}, "three": {13, "c"}})
-
-	testEachMapValNilable(t, "empty", map[string]*int{})
-	testEachMapValNilable(t, "empty", map[string]*string{})
-	testEachMapValNilable(t, "empty", map[string]*TestStruct{})
-
-	testEachMapValNilable[int](t, "nil", nil)
-	testEachMapValNilable[string](t, "nil", nil)
-	testEachMapValNilable[TestStruct](t, "nil", nil)
-}
-
-func TestEachMapValNilableSlice(t *testing.T) {
-	testEachMapValNilable(t, "valid", map[string][]int{
-		"one":   {11, 12, 13},
-		"two":   {12, 13, 14},
-		"three": {13, 14, 15}})
-	testEachMapValNilable(t, "valid", map[string][]string{
-		"A": {"a", "b", "c"},
-		"B": {"b", "c", "d"},
-		"C": {"c", "d", "e"}})
-	testEachMapValNilable(t, "valid", map[string][]TestStruct{
-		"one":   {{11, "a"}, {12, "b"}, {13, "c"}},
-		"two":   {{12, "a"}, {13, "b"}, {14, "c"}},
-		"three": {{13, "a"}, {14, "b"}, {15, "c"}}})
-
-	testEachMapValNilable(t, "empty", map[string][]int{"a": {}, "b": {}, "c": {}})
-	testEachMapValNilable(t, "empty", map[string][]string{"a": {}, "b": {}, "c": {}})
-	testEachMapValNilable(t, "empty", map[string][]TestStruct{"a": {}, "b": {}, "c": {}})
-
-	testEachMapValNilable[int](t, "nil", nil)
-	testEachMapValNilable[string](t, "nil", nil)
-	testEachMapValNilable[TestStruct](t, "nil", nil)
-}
-
-func testEachMapValNilable[T any](t *testing.T, name string, input map[string]T) {
-	var zero T
-	t.Run(fmt.Sprintf("%s(%T)", name, zero), func(t *testing.T) {
-		calls := 0
-		vfn := func(ctx context.Context, op operation.Operation, fldPath *field.Path, newVal, oldVal T) field.ErrorList {
-			if !reflect.DeepEqual(oldVal, zero) {
-				t.Errorf("expected nil oldVal, got %v", oldVal)
-			}
-			calls++
-			return nil
-		}
-		_ = EachMapValNilable(context.Background(), operation.Operation{}, field.NewPath("test"), input, nil, vfn)
-		if calls != len(input) {
-			t.Errorf("expected %d calls, got %d", len(input), calls)
-		}
-	})
-}
-
 type StringType string
 
 func TestEachMapKey(t *testing.T) {

staging/src/k8s.io/code-generator/cmd/validation-gen/output_tests/cross_pkg/doc.go

@@ -90,36 +90,20 @@ type T1 struct {
 	// +k8s:eachVal=+k8s:validateTrue="field T1.SliceOfOtherStruct values"
 	// +k8s:eachVal=+k8s:opaqueType
 	SliceOfOtherStruct []other.StructType `json:"sliceOfOtherStruct"`
-	// +k8s:validateTrue="field T1.SliceOfOtherStructPtr"
-	// +k8s:eachVal=+k8s:validateTrue="field T1.SliceOfOtherStructPtr values"
-	// +k8s:eachVal=+k8s:opaqueType
-	SliceOfOtherStructPtr []*other.StructType `json:"sliceOfOtherStructPtr"`
 
 	// +k8s:validateTrue="field T1.ListMapOfOtherStruct"
 	// +k8s:eachVal=+k8s:validateTrue="field T1.SliceOfOtherStruct values"
 	// +k8s:listType=map
 	// +k8s:listMapKey=stringField
 	// +k8s:eachVal=+k8s:opaqueType
 	ListMapOfOtherStruct []other.StructType `json:"listMapOfOtherStruct"`
-	// +k8s:validateTrue="field T1.ListMapOfOtherStructPtr"
-	// +k8s:eachVal=+k8s:validateTrue="field T1.SliceOfOtherStructPtr values"
-	// +k8s:listType=map
-	// +k8s:listMapKey=stringField
-	// +k8s:eachVal=+k8s:opaqueType
-	ListMapOfOtherStructPtr []*other.StructType `json:"listMapOfOtherStructPtr"`
 
 	// +k8s:validateTrue="field T1.MapOfOtherStringToOtherStruct"
 	// +k8s:eachKey=+k8s:validateTrue="field T1.MapOfOtherStringToOtherStruct keys"
 	// +k8s:eachVal=+k8s:validateTrue="field T1.MapOfOtherStringToOtherStruct values"
 	// +k8s:eachKey=+k8s:opaqueType
 	// +k8s:eachVal=+k8s:opaqueType
 	MapOfOtherStringToOtherStruct map[other.StringType]other.StructType `json:"mapOfOtherStringToOtherStruct"`
-	// +k8s:validateTrue="field T1.MapOfOtherStringToOtherStructPtr"
-	// +k8s:eachKey=+k8s:validateTrue="field T1.MapOfOtherStringToOtherStructPtr keys"
-	// +k8s:eachVal=+k8s:validateTrue="field T1.MapOfOtherStringToOtherStructPtr values"
-	// +k8s:eachKey=+k8s:opaqueType
-	// +k8s:eachVal=+k8s:opaqueType
-	MapOfOtherStringToOtherStructPtr map[other.StringType]*other.StructType `json:"mapOfOtherStringToOtherStructPtr"`
 }
 
 // TODO: the validateFalse test fixture doesn't handle map and slice types, and