Handle typedef fields in optional validations

Prior to this it would look at the .Kind, see "Alias", and generate
calls to (e.g.) `RequiredValue()`.  Now calls `RequiredSlice()`.

Author: thockin

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

@@ -69,9 +69,17 @@ type Struct struct {
 	// +k8s:validateFalse="field Struct.SliceField"
 	SliceField []string `json:"sliceField"`
 
+	// +k8s:optional
+	// +k8s:validateFalse="field Struct.SliceTypedefField"
+	SliceTypedefField SliceType `json:"sliceTypedefField"`
+
 	// +k8s:optional
 	// +k8s:validateFalse="field Struct.MapField"
 	MapField map[string]string `json:"mapField"`
+
+	// +k8s:optional
+	// +k8s:validateFalse="field Struct.MapTypedefField"
+	MapTypedefField MapType `json:"mapTypedefField"`
 }
 
 // +k8s:validateFalse="type StringType"
@@ -82,3 +90,9 @@ type IntType int
 
 // +k8s:validateFalse="type OtherStruct"
 type OtherStruct struct{}
+
+// +k8s:validateFalse="type SliceType"
+type SliceType []string
+
+// +k8s:validateFalse="type MapType"
+type MapType map[string]string

staging/src/k8s.io/code-generator/cmd/validation-gen/output_tests/tags/optional/doc_test.go

@@ -40,7 +40,9 @@ func Test(t *testing.T) {
 		IntTypedefPtrField:    ptr.To(IntType(456)),
 		OtherStructPtrField:   &OtherStruct{},
 		SliceField:            []string{"a", "b"},
+		SliceTypedefField:     SliceType([]string{"a", "b"}),
 		MapField:              map[string]string{"a": "b", "c": "d"},
+		MapTypedefField:       MapType(map[string]string{"a": "b", "c": "d"}),
 	}).ExpectValidateFalseByPath(map[string][]string{
 		"stringField":           {"field Struct.StringField"},
 		"stringPtrField":        {"field Struct.StringPtrField"},
@@ -52,6 +54,8 @@ func Test(t *testing.T) {
 		"intTypedefPtrField":    {"field Struct.IntTypedefPtrField", "type IntType"},
 		"otherStructPtrField":   {"type OtherStruct", "field Struct.OtherStructPtrField"},
 		"sliceField":            {"field Struct.SliceField"},
+		"sliceTypedefField":     {"field Struct.SliceTypedefField", "type SliceType"},
 		"mapField":              {"field Struct.MapField"},
+		"mapTypedefField":       {"field Struct.MapTypedefField", "type MapType"},
 	})
 }

staging/src/k8s.io/code-generator/cmd/validation-gen/output_tests/tags/optional/zz_generated.validations.go

@@ -40,16 +40,22 @@ func getMemberByJSON(t *types.Type, jsonName string) *types.Member {
 
 // isNilableType returns true if the argument type can be compared to nil.
 func isNilableType(t *types.Type) bool {
-	for t.Kind == types.Alias {
-		t = t.Underlying
-	}
-	switch t.Kind {
+	switch unaliasType(t).Kind {
 	case types.Pointer, types.Map, types.Slice, types.Interface: // Note: Arrays are not nilable
 		return true
 	}
 	return false
 }
 
+// unaliasType returns the underlying type of the specified type if it is an
+// alias, otherwise returns the type itself.
+func unaliasType(t *types.Type) *types.Type {
+	for t.Kind == types.Alias {
+		t = t.Underlying
+	}
+	return t
+}
+
 // realType returns the underlying type of a type, unwrapping aliases and
 // dropping pointerness.
 func realType(t *types.Type) *types.Type {

staging/src/k8s.io/code-generator/cmd/validation-gen/validators/common.go

@@ -90,7 +90,7 @@ func (rtv requirednessTagValidator) doRequired(context Context) (Validations, er
 	// originally defined as a value-type or a pointer-type in the API.  This
 	// one does.  Since Go doesn't do partial specialization of templates, we
 	// do manual dispatch here.
-	switch context.Type.Kind {
+	switch unaliasType(context.Type).Kind {
 	case types.Slice:
 		return Validations{Functions: []FunctionGen{Function(requiredTagName, ShortCircuit, requiredSliceValidator)}}, nil
 	case types.Map:
@@ -161,7 +161,7 @@ func (rtv requirednessTagValidator) doOptional(context Context) (Validations, er
 	// originally defined as a value-type or a pointer-type in the API.  This
 	// one does.  Since Go doesn't do partial specialization of templates, we
 	// do manual dispatch here.
-	switch context.Type.Kind {
+	switch unaliasType(context.Type).Kind {
 	case types.Slice:
 		return Validations{Functions: []FunctionGen{Function(optionalTagName, ShortCircuit|NonError, optionalSliceValidator)}}, nil
 	case types.Map:
@@ -261,7 +261,7 @@ func (requirednessTagValidator) doForbidden(context Context) (Validations, error
 	// optional check and short-circuit (but without error).  Why?  For
 	// example, this prevents any further validation from trying to run on a
 	// nil pointer.
-	switch context.Type.Kind {
+	switch unaliasType(context.Type).Kind {
 	case types.Slice:
 		return Validations{
 			Functions: []FunctionGen{