Merge pull request #130827 from thockin/kk_refactor_FunctionGen

validation-gen: Simplify FunctionGen and VariableGen

Kubernetes-commit: 18e5a4d585f6e3034b10b6b33f5aef436b5c49ce

Author: k8s-publishing-bot

cmd/validation-gen/validation.go

@@ -1100,7 +1100,7 @@ func emitCallsToValidators(c *generator.Context, validations []validators.Functi
 		later := make([]validators.FunctionGen, 0, len(in))
 
 		for _, fg := range in {
-			isShortCircuit := (fg.Flags().IsSet(validators.ShortCircuit))
+			isShortCircuit := (fg.Flags.IsSet(validators.ShortCircuit))
 
 			if isShortCircuit {
 				sooner = append(sooner, fg)
@@ -1116,19 +1116,17 @@ func emitCallsToValidators(c *generator.Context, validations []validators.Functi
 	validations = sort(validations)
 
 	for _, v := range validations {
-		isShortCircuit := v.Flags().IsSet(validators.ShortCircuit)
-		isNonError := v.Flags().IsSet(validators.NonError)
+		isShortCircuit := v.Flags.IsSet(validators.ShortCircuit)
+		isNonError := v.Flags.IsSet(validators.NonError)
 
-		fn, extraArgs := v.SignatureAndArgs()
 		targs := generator.Args{
-			"funcName": c.Universe.Type(fn),
+			"funcName": c.Universe.Type(v.Function),
 			"field":    mkSymbolArgs(c, fieldPkgSymbols),
 		}
 
 		emitCall := func() {
 			sw.Do("$.funcName|raw$", targs)
-			typeArgs := v.TypeArgs()
-			if len(typeArgs) > 0 {
+			if typeArgs := v.TypeArgs; len(typeArgs) > 0 {
 				sw.Do("[", nil)
 				for i, typeArg := range typeArgs {
 					sw.Do("$.|raw$", c.Universe.Type(typeArg))
@@ -1139,29 +1137,29 @@ func emitCallsToValidators(c *generator.Context, validations []validators.Functi
 				sw.Do("]", nil)
 			}
 			sw.Do("(ctx, op, fldPath, obj, oldObj", targs)
-			for _, arg := range extraArgs {
+			for _, arg := range v.Args {
 				sw.Do(", ", nil)
 				toGolangSourceDataLiteral(sw, c, arg)
 			}
 			sw.Do(")", targs)
 		}
 
 		// If validation is conditional, wrap the validation function with a conditions check.
-		if !v.Conditions().Empty() {
+		if !v.Conditions.Empty() {
 			emitBaseFunction := emitCall
 			emitCall = func() {
 				sw.Do("func() $.field.ErrorList|raw$ {\n", targs)
 				sw.Do("  if ", nil)
 				firstCondition := true
-				if len(v.Conditions().OptionEnabled) > 0 {
-					sw.Do("op.Options.Has($.$)", strconv.Quote(v.Conditions().OptionEnabled))
+				if len(v.Conditions.OptionEnabled) > 0 {
+					sw.Do("op.Options.Has($.$)", strconv.Quote(v.Conditions.OptionEnabled))
 					firstCondition = false
 				}
-				if len(v.Conditions().OptionDisabled) > 0 {
+				if len(v.Conditions.OptionDisabled) > 0 {
 					if !firstCondition {
 						sw.Do(" && ", nil)
 					}
-					sw.Do("!op.Options.Has($.$)", strconv.Quote(v.Conditions().OptionDisabled))
+					sw.Do("!op.Options.Has($.$)", strconv.Quote(v.Conditions.OptionDisabled))
 				}
 				sw.Do(" {\n", nil)
 				sw.Do("    return ", nil)
@@ -1174,7 +1172,7 @@ func emitCallsToValidators(c *generator.Context, validations []validators.Functi
 			}
 		}
 
-		for _, comment := range v.Comments() {
+		for _, comment := range v.Comments {
 			sw.Do("// $.$\n", comment)
 		}
 		if isShortCircuit {
@@ -1214,21 +1212,19 @@ func (g *genValidations) emitValidationVariables(c *generator.Context, t *types.
 
 	variables := tn.typeValidations.Variables
 	slices.SortFunc(variables, func(a, b validators.VariableGen) int {
-		return cmp.Compare(a.Var().Name, b.Var().Name)
+		return cmp.Compare(a.Variable.Name, b.Variable.Name)
 	})
 	for _, variable := range variables {
-		fn := variable.Init()
-		supportInitFn, supportInitArgs := fn.SignatureAndArgs()
+		fn := variable.InitFunc
 		targs := generator.Args{
-			"varName": c.Universe.Type(types.Name(variable.Var())),
-			"initFn":  c.Universe.Type(supportInitFn),
+			"varName": c.Universe.Type(types.Name(variable.Variable)),
+			"initFn":  c.Universe.Type(fn.Function),
 		}
-		for _, comment := range fn.Comments() {
+		for _, comment := range fn.Comments {
 			sw.Do("// $.$\n", comment)
 		}
 		sw.Do("var $.varName|private$ = $.initFn|raw$", targs)
-		typeArgs := variable.Init().TypeArgs()
-		if len(typeArgs) > 0 {
+		if typeArgs := fn.TypeArgs; len(typeArgs) > 0 {
 			sw.Do("[", nil)
 			for i, typeArg := range typeArgs {
 				sw.Do("$.|raw$", c.Universe.Type(typeArg))
@@ -1239,11 +1235,11 @@ func (g *genValidations) emitValidationVariables(c *generator.Context, t *types.
 			sw.Do("]", nil)
 		}
 		sw.Do("(", targs)
-		for i, arg := range supportInitArgs {
-			toGolangSourceDataLiteral(sw, c, arg)
-			if i < len(supportInitArgs)-1 {
+		for i, arg := range fn.Args {
+			if i != 0 {
 				sw.Do(", ", nil)
 			}
+			toGolangSourceDataLiteral(sw, c, arg)
 		}
 		sw.Do(")\n", nil)
 
@@ -1277,22 +1273,21 @@ func toGolangSourceDataLiteral(sw *generator.SnippetWriter, c *generator.Context
 	case *validators.PrivateVar:
 		sw.Do("$.|private$", c.Universe.Type(types.Name(*v)))
 	case validators.WrapperFunction:
-		fn, extraArgs := v.Function.SignatureAndArgs()
-		if len(extraArgs) == 0 {
+		if extraArgs := v.Function.Args; len(extraArgs) == 0 {
 			// If the function to be wrapped has no additional arguments, we can
 			// just use it directly.
 			targs := generator.Args{
-				"funcName": c.Universe.Type(fn),
+				"funcName": c.Universe.Type(v.Function.Function),
 			}
-			for _, comment := range v.Function.Comments() {
+			for _, comment := range v.Function.Comments {
 				sw.Do("// $.$\n", comment)
 			}
 			sw.Do("$.funcName|raw$", targs)
 		} else {
 			// If the function to be wrapped has additional arguments, we need
 			// a "standard signature" validation function to wrap it.
 			targs := generator.Args{
-				"funcName":   c.Universe.Type(fn),
+				"funcName":   c.Universe.Type(v.Function.Function),
 				"field":      mkSymbolArgs(c, fieldPkgSymbols),
 				"operation":  mkSymbolArgs(c, operationPkgSymbols),
 				"context":    mkSymbolArgs(c, contextPkgSymbols),
@@ -1305,7 +1300,7 @@ func toGolangSourceDataLiteral(sw *generator.SnippetWriter, c *generator.Context
 
 			emitCall := func() {
 				sw.Do("return $.funcName|raw$", targs)
-				typeArgs := v.Function.TypeArgs()
+				typeArgs := v.Function.TypeArgs
 				if len(typeArgs) > 0 {
 					sw.Do("[", nil)
 					for i, typeArg := range typeArgs {

cmd/validation-gen/validators/each.go

@@ -286,7 +286,7 @@ func (evtv eachValTagValidator) getListValidations(fldPath *field.Path, t *types
 			cmpFn.Body = buf.String()
 			cmpArg = cmpFn
 		}
-		f := Function(eachValTagName, vfn.Flags(), validateEachSliceVal, cmpArg, WrapperFunction{vfn, t.Elem})
+		f := Function(eachValTagName, vfn.Flags, validateEachSliceVal, cmpArg, WrapperFunction{vfn, t.Elem})
 		result.Functions = append(result.Functions, f)
 	}
 
@@ -298,7 +298,7 @@ func (evtv eachValTagValidator) getMapValidations(t *types.Type, validations Val
 	result.OpaqueValType = validations.OpaqueType
 
 	for _, vfn := range validations.Functions {
-		f := Function(eachValTagName, vfn.Flags(), validateEachMapVal, WrapperFunction{vfn, t.Elem})
+		f := Function(eachValTagName, vfn.Flags, validateEachMapVal, WrapperFunction{vfn, t.Elem})
 		result.Functions = append(result.Functions, f)
 	}
 
@@ -369,7 +369,7 @@ func (ektv eachKeyTagValidator) getValidations(t *types.Type, validations Valida
 	result := Validations{}
 	result.OpaqueKeyType = validations.OpaqueType
 	for _, vfn := range validations.Functions {
-		f := Function(eachKeyTagName, vfn.Flags(), validateEachMapKey, WrapperFunction{vfn, t.Key})
+		f := Function(eachKeyTagName, vfn.Flags, validateEachMapKey, WrapperFunction{vfn, t.Key})
 		result.Functions = append(result.Functions, f)
 	}
 	return result, nil

cmd/validation-gen/validators/registry.go

@@ -165,7 +165,7 @@ func (reg *registry) sortTagsIntoPhases(tags map[string][]gengo.Tag) [][]string
 	// Tag extraction will retain the relative order between 111 and 222, but
 	// 333 is extracted as tag "k8s:ifOptionEnabled".  Those are all in a map,
 	// which we iterate (in a random order).  When it reaches the emit stage,
-	// the "ifOptionEnabled" part is gone, and we will have 3 functionGen
+	// the "ifOptionEnabled" part is gone, and we will have 3 FunctionGen
 	// objects, all with tag "k8s:validateFalse", in a non-deterministic order
 	// because of the map iteration.  If we sort them at that point, we won't
 	// have enough information to do something smart, unless we look at the

cmd/validation-gen/validators/required.go

@@ -156,7 +156,7 @@ func (rtv requirednessTagValidator) doOptional(context Context) (Validations, er
 			return Validations{}, err
 		}
 		for i, fn := range validations.Functions {
-			validations.Functions[i] = WithComment(fn, "optional fields with default values are effectively required")
+			validations.Functions[i] = fn.WithComment("optional fields with default values are effectively required")
 		}
 		return validations, nil
 	}

cmd/validation-gen/validators/subfield.go

@@ -100,7 +100,7 @@ func (stv subfieldTagValidator) GetValidations(context Context, args []string, p
 				Results:    []ParamResult{{"", nilableFieldType}},
 			}
 			getFn.Body = fmt.Sprintf("return %so.%s", fieldExprPrefix, submemb.Name)
-			f := Function(subfieldTagName, vfn.Flags(), validateSubfield, subname, getFn, WrapperFunction{vfn, submemb.Type})
+			f := Function(subfieldTagName, vfn.Flags, validateSubfield, subname, getFn, WrapperFunction{vfn, submemb.Type})
 			result.Functions = append(result.Functions, f)
 			result.Variables = append(result.Variables, validations.Variables...)
 		}

cmd/validation-gen/validators/testing.go

@@ -73,7 +73,7 @@ func (frtv fixedResultTagValidator) GetValidations(context Context, _ []string,
 	if err != nil {
 		return result, fmt.Errorf("can't decode tag payload: %w", err)
 	}
-	result.AddFunction(GenericFunction(frtv.TagName(), tag.flags, fixedResultValidator, tag.typeArgs, frtv.result, tag.msg))
+	result.AddFunction(Function(frtv.TagName(), tag.flags, fixedResultValidator, frtv.result, tag.msg).WithTypeArgs(tag.typeArgs...))
 
 	return result, nil
 }