Get rid of gengo CustomArgs

staging/src/k8s.io/code-generator/cmd/applyconfiguration-gen/args/args.go

@@ -20,12 +20,11 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/types"
 )
 
-// CustomArgs is a wrapper for arguments to applyconfiguration-gen.
+// Args is a wrapper for arguments to applyconfiguration-gen.
-type CustomArgs struct {
+type Args struct {
 	OutputDir string // must be a directory path
 	OutputPkg string // must be a Go import-path
 
@@ -46,10 +45,9 @@ type CustomArgs struct {
 	OpenAPISchemaFilePath string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{
-	customArgs := &CustomArgs{
 		ExternalApplyConfigurations: map[types.Name]string{
 			// Always include the applyconfigurations we've generated in client-go. They are sufficient for the vast majority of use cases.
 			{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "Condition"}:                "k8s.io/client-go/applyconfigurations/meta/v1",
@@ -62,35 +60,29 @@ func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
 			{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "TypeMeta"}:                 "k8s.io/client-go/applyconfigurations/meta/v1",
 		},
 	}
-	genericArgs.CustomArgs = customArgs
-
-	return genericArgs, customArgs
 }
 
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet, inputBase string) {
+func (args *Args) AddFlags(fs *pflag.FlagSet, inputBase string) {
-	fs.StringVar(&ca.OutputDir, "output-dir", "",
+	fs.StringVar(&args.OutputDir, "output-dir", "",
 		"the base directory under which to generate results")
-	fs.StringVar(&ca.OutputPkg, "output-pkg", ca.OutputPkg,
+	fs.StringVar(&args.OutputPkg, "output-pkg", args.OutputPkg,
 		"the Go import-path of the generated results")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
-	fs.Var(NewExternalApplyConfigurationValue(&ca.ExternalApplyConfigurations, nil), "external-applyconfigurations",
+	fs.Var(NewExternalApplyConfigurationValue(&args.ExternalApplyConfigurations, nil), "external-applyconfigurations",
 		"list of comma separated external apply configurations locations in <type-package>.<type-name>:<applyconfiguration-package> form."+
 			"For example: k8s.io/api/apps/v1.Deployment:k8s.io/client-go/applyconfigurations/apps/v1")
-	fs.StringVar(&ca.OpenAPISchemaFilePath, "openapi-schema", "",
+	fs.StringVar(&args.OpenAPISchemaFilePath, "openapi-schema", "",
 		"path to the openapi schema containing all the types that apply configurations will be generated for")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	customArgs := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputDir) == 0 {
-
-	if len(customArgs.OutputDir) == 0 {
 		return fmt.Errorf("--output-dir must be specified")
 	}
-	if len(customArgs.OutputPkg) == 0 {
+	if len(args.OutputPkg) == 0 {
 		return fmt.Errorf("--output-pkg must be specified")
 	}
-
 	return nil
 }

staging/src/k8s.io/code-generator/cmd/applyconfiguration-gen/generators/targets.go

@@ -23,13 +23,13 @@ import (
 	"sort"
 	"strings"
 
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
 	"k8s.io/klog/v2"
 
-	applygenargs "k8s.io/code-generator/cmd/applyconfiguration-gen/args"
+	"k8s.io/code-generator/cmd/applyconfiguration-gen/args"
 	"k8s.io/code-generator/cmd/client-gen/generators/util"
 	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
 )
@@ -55,20 +55,18 @@ func DefaultNameSystem() string {
 }
 
 // GetTargets makes the client target definition.
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*applygenargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
-	pkgTypes := packageTypesForInputs(context, customArgs.OutputPkg)
+	pkgTypes := packageTypesForInputs(context, args.OutputPkg)
-	initialTypes := customArgs.ExternalApplyConfigurations
+	initialTypes := args.ExternalApplyConfigurations
 	refs := refGraphForReachableTypes(context.Universe, pkgTypes, initialTypes)
-	typeModels, err := newTypeModels(customArgs.OpenAPISchemaFilePath, pkgTypes)
+	typeModels, err := newTypeModels(args.OpenAPISchemaFilePath, pkgTypes)
 	if err != nil {
-		klog.Fatalf("Failed build type models from typeModels %s: %v", customArgs.OpenAPISchemaFilePath, err)
+		klog.Fatalf("Failed build type models from typeModels %s: %v", args.OpenAPISchemaFilePath, err)
 	}
 
 	groupVersions := make(map[string]clientgentypes.GroupVersions)
@@ -103,13 +101,13 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 		// Apparently we allow the groupName to be overridden in a way that it
 		// no longer maps to a Go package by name.  So we have to figure out
 		// the offset of this particular output package (pkg) from the base
-		// output package (customArgs.OutputPkg).
+		// output package (args.OutputPkg).
-		pkgSubdir := strings.TrimPrefix(pkg, customArgs.OutputPkg+"/")
+		pkgSubdir := strings.TrimPrefix(pkg, args.OutputPkg+"/")
 
 		// generate the apply configurations
 		targetList = append(targetList,
 			targetForApplyConfigurationsPackage(
-				customArgs.OutputDir, customArgs.OutputPkg, pkgSubdir,
+				args.OutputDir, args.OutputPkg, pkgSubdir,
 				boilerplate, gv, toGenerate, refs, typeModels))
 
 		// group all the generated apply configurations by gv so ForKind() can be generated
@@ -133,11 +131,11 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 
 	// generate ForKind() utility function
 	targetList = append(targetList,
-		targetForUtils(customArgs.OutputDir, customArgs.OutputPkg,
+		targetForUtils(args.OutputDir, args.OutputPkg,
 			boilerplate, groupVersions, applyConfigsForGroupVersion, groupGoNames))
 	// generate internal embedded schema, required for generated Extract functions
 	targetList = append(targetList,
-		targetForInternal(customArgs.OutputDir, customArgs.OutputPkg,
+		targetForInternal(args.OutputDir, args.OutputPkg,
 			boilerplate, typeModels))
 
 	return targetList

staging/src/k8s.io/code-generator/cmd/applyconfiguration-gen/main.go

@@ -21,34 +21,37 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	"k8s.io/klog/v2"
+	"k8s.io/code-generator/cmd/applyconfiguration-gen/args"
-
-	generatorargs "k8s.io/code-generator/cmd/applyconfiguration-gen/args"
 	"k8s.io/code-generator/cmd/applyconfiguration-gen/generators"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
+	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of applyconfiguration-gen
-	customArgs.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of applyconfiguration-gen
 	if err := flag.Set("logtostderr", "true"); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/client-gen/args/args.go

@@ -20,13 +20,11 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 
 	"k8s.io/code-generator/cmd/client-gen/types"
 )
 
-// CustomArgs is a wrapper for arguments to client-gen.
+type Args struct {
-type CustomArgs struct {
 	// The directory for the generated results.
 	OutputDir string
 
@@ -65,9 +63,8 @@ type CustomArgs struct {
 	ApplyConfigurationPackage string
 }
 
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{
-	customArgs := &CustomArgs{
 		ClientsetName:             "internalclientset",
 		ClientsetAPIPath:          "/apis",
 		ClientsetOnly:             false,
@@ -75,47 +72,50 @@ func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
 		PluralExceptions:          []string{"Endpoints:Endpoints"},
 		ApplyConfigurationPackage: "",
 	}
-	genericArgs.CustomArgs = customArgs
-
-	return genericArgs, customArgs
 }
 
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet, inputBase string) {
+func (args *Args) AddFlags(fs *pflag.FlagSet, inputBase string) {
-	gvsBuilder := NewGroupVersionsBuilder(&ca.Groups)
+	gvsBuilder := NewGroupVersionsBuilder(&args.Groups)
-	fs.StringVar(&ca.OutputDir, "output-dir", "",
+	fs.StringVar(&args.OutputDir, "output-dir", "",
 		"the base directory under which to generate results")
-	fs.StringVar(&ca.OutputPkg, "output-pkg", ca.OutputPkg,
+	fs.StringVar(&args.OutputPkg, "output-pkg", args.OutputPkg,
 		"the Go import-path of the generated results")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
-	fs.Var(NewGVPackagesValue(gvsBuilder, nil), "input", "group/versions that client-gen will generate clients for. At most one version per group is allowed. Specified in the format \"group1/version1,group2/version2...\".")
+	fs.Var(NewGVPackagesValue(gvsBuilder, nil), "input",
-	fs.Var(NewGVTypesValue(&ca.IncludedTypesOverrides, []string{}), "included-types-overrides", "list of group/version/type for which client should be generated. By default, client is generated for all types which have genclient in types.go. This overrides that. For each groupVersion in this list, only the types mentioned here will be included. The default check of genclient will be used for other group versions.")
+		"group/versions that client-gen will generate clients for. At most one version per group is allowed. Specified in the format \"group1/version1,group2/version2...\".")
-	fs.Var(NewInputBasePathValue(gvsBuilder, inputBase), "input-base", "base path to look for the api group.")
+	fs.Var(NewGVTypesValue(&args.IncludedTypesOverrides, []string{}), "included-types-overrides",
-	fs.StringVarP(&ca.ClientsetName, "clientset-name", "n", ca.ClientsetName, "the name of the generated clientset package.")
+		"list of group/version/type for which client should be generated. By default, client is generated for all types which have genclient in types.go. This overrides that. For each groupVersion in this list, only the types mentioned here will be included. The default check of genclient will be used for other group versions.")
-	fs.StringVarP(&ca.ClientsetAPIPath, "clientset-api-path", "", ca.ClientsetAPIPath, "the value of default API HTTP path, starting with / and without trailing /.")
+	fs.Var(NewInputBasePathValue(gvsBuilder, inputBase), "input-base",
-	fs.BoolVar(&ca.ClientsetOnly, "clientset-only", ca.ClientsetOnly, "when set, client-gen only generates the clientset shell, without generating the individual typed clients")
+		"base path to look for the api group.")
-	fs.BoolVar(&ca.FakeClient, "fake-clientset", ca.FakeClient, "when set, client-gen will generate the fake clientset that can be used in tests")
+	fs.StringVarP(&args.ClientsetName, "clientset-name", "n", args.ClientsetName,
-
+		"the name of the generated clientset package.")
-	fs.StringSliceVar(&ca.PluralExceptions, "plural-exceptions", ca.PluralExceptions, "list of comma separated plural exception definitions in Type:PluralizedType form")
+	fs.StringVarP(&args.ClientsetAPIPath, "clientset-api-path", "", args.ClientsetAPIPath,
-	fs.StringVar(&ca.ApplyConfigurationPackage, "apply-configuration-package", ca.ApplyConfigurationPackage, "optional package of apply configurations, generated by applyconfiguration-gen, that are required to generate Apply functions for each type in the clientset. By default Apply functions are not generated.")
+		"the value of default API HTTP path, starting with / and without trailing /.")
+	fs.BoolVar(&args.ClientsetOnly, "clientset-only", args.ClientsetOnly,
+		"when set, client-gen only generates the clientset shell, without generating the individual typed clients")
+	fs.BoolVar(&args.FakeClient, "fake-clientset", args.FakeClient,
+		"when set, client-gen will generate the fake clientset that can be used in tests")
+	fs.StringSliceVar(&args.PluralExceptions, "plural-exceptions", args.PluralExceptions,
+		"list of comma separated plural exception definitions in Type:PluralizedType form")
+	fs.StringVar(&args.ApplyConfigurationPackage, "apply-configuration-package", args.ApplyConfigurationPackage,
+		"optional package of apply configurations, generated by applyconfiguration-gen, that are required to generate Apply functions for each type in the clientset. By default Apply functions are not generated.")
 
 	// support old flags
 	fs.SetNormalizeFunc(mapFlagName("clientset-path", "output-pkg", fs.GetNormalizeFunc()))
 }
 
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	customArgs := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputDir) == 0 {
-
-	if len(customArgs.OutputDir) == 0 {
 		return fmt.Errorf("--output-dir must be specified")
 	}
-	if len(customArgs.OutputPkg) == 0 {
+	if len(args.OutputPkg) == 0 {
 		return fmt.Errorf("--output-pkg must be specified")
 	}
-	if len(customArgs.ClientsetName) == 0 {
+	if len(args.ClientsetName) == 0 {
 		return fmt.Errorf("--clientset-name must be specified")
 	}
-	if len(customArgs.ClientsetAPIPath) == 0 {
+	if len(args.ClientsetAPIPath) == 0 {
 		return fmt.Errorf("--clientset-api-path cannot be empty")
 	}
 
@@ -123,9 +123,9 @@ func Validate(genericArgs *args.GeneratorArgs) error {
 }
 
 // GroupVersionPackages returns a map from GroupVersion to the package with the types.go.
-func (ca *CustomArgs) GroupVersionPackages() map[types.GroupVersion]string {
+func (args *Args) GroupVersionPackages() map[types.GroupVersion]string {
 	res := map[types.GroupVersion]string{}
-	for _, pkg := range ca.Groups {
+	for _, pkg := range args.Groups {
 		for _, v := range pkg.Versions {
 			res[types.GroupVersion{Group: pkg.Group, Version: v.Version}] = v.Package
 		}

staging/src/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go

@@ -22,13 +22,13 @@ import (
 	"path/filepath"
 	"strings"
 
-	clientgenargs "k8s.io/code-generator/cmd/client-gen/args"
+	"k8s.io/code-generator/cmd/client-gen/args"
 	"k8s.io/code-generator/cmd/client-gen/generators/fake"
 	"k8s.io/code-generator/cmd/client-gen/generators/scheme"
 	"k8s.io/code-generator/cmd/client-gen/generators/util"
 	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
 	codegennamer "k8s.io/code-generator/pkg/namer"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
@@ -196,9 +196,9 @@ func targetForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clie
 	}
 }
 
-func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
+func targetForClientset(args *args.Args, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
 	return &generator.SimpleTarget{
-		PkgName:       customArgs.ClientsetName,
+		PkgName:       args.ClientsetName,
 		PkgPath:       clientsetPkg,
 		PkgDir:        clientsetDir,
 		HeaderComment: boilerplate,
@@ -210,7 +210,7 @@ func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
 					GoGenerator: generator.GoGenerator{
 						OutputFilename: "clientset.go",
 					},
-					groups:           customArgs.Groups,
+					groups:           args.Groups,
 					groupGoNames:     groupGoNames,
 					clientsetPackage: clientsetPkg,
 					imports:          generator.NewImportTracker(),
@@ -221,14 +221,14 @@ func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
 	}
 }
 
-func targetForScheme(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
+func targetForScheme(args *args.Args, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
 	schemeDir := filepath.Join(clientsetDir, "scheme")
 	schemePkg := filepath.Join(clientsetPkg, "scheme")
 
 	// create runtime.Registry for internal client because it has to know about group versions
 	internalClient := false
 NextGroup:
-	for _, group := range customArgs.Groups {
+	for _, group := range args.Groups {
 		for _, v := range group.Versions {
 			if v.String() == "" {
 				internalClient = true
@@ -254,10 +254,10 @@ NextGroup:
 					GoGenerator: generator.GoGenerator{
 						OutputFilename: "register.go",
 					},
-					InputPackages:  customArgs.GroupVersionPackages(),
+					InputPackages:  args.GroupVersionPackages(),
 					OutputPkg:      schemePkg,
 					OutputPath:     schemeDir,
-					Groups:         customArgs.Groups,
+					Groups:         args.Groups,
 					GroupGoNames:   groupGoNames,
 					ImportTracker:  generator.NewImportTracker(),
 					CreateRegistry: internalClient,
@@ -273,10 +273,10 @@ NextGroup:
 // first field (somegroup) as the name of the group in Go code, e.g. as the func name in a clientset.
 //
 // If the first field of the groupName is not unique within the clientset, use "// +groupName=unique
-func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.CustomArgs) {
+func applyGroupOverrides(universe types.Universe, args *args.Args) {
 	// Create a map from "old GV" to "new GV" so we know what changes we need to make.
 	changes := make(map[clientgentypes.GroupVersion]clientgentypes.GroupVersion)
-	for gv, inputDir := range customArgs.GroupVersionPackages() {
+	for gv, inputDir := range args.GroupVersionPackages() {
 		p := universe.Package(inputDir)
 		if override := types.ExtractCommentTags("+", p.Comments)["groupName"]; override != nil {
 			newGV := clientgentypes.GroupVersion{
@@ -287,9 +287,9 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust
 		}
 	}
 
-	// Modify customArgs.Groups based on the groupName overrides.
+	// Modify args.Groups based on the groupName overrides.
-	newGroups := make([]clientgentypes.GroupVersions, 0, len(customArgs.Groups))
+	newGroups := make([]clientgentypes.GroupVersions, 0, len(args.Groups))
-	for _, gvs := range customArgs.Groups {
+	for _, gvs := range args.Groups {
 		gv := clientgentypes.GroupVersion{
 			Group:   gvs.Group,
 			Version: gvs.Versions[0].Version, // we only need a version, and the first will do
@@ -307,7 +307,7 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust
 			newGroups = append(newGroups, gvs)
 		}
 	}
-	customArgs.Groups = newGroups
+	args.Groups = newGroups
 }
 
 // Because we try to assemble inputs from an input-base and a set of
@@ -316,9 +316,9 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust
 //
 // TODO: Change this tool to just take inputs as Go "patterns" like every other
 // gengo tool, then extract GVs from those.
-func sanitizePackagePaths(context *generator.Context, ca *clientgenargs.CustomArgs) error {
+func sanitizePackagePaths(context *generator.Context, args *args.Args) error {
-	for i := range ca.Groups {
+	for i := range args.Groups {
-		pkg := &ca.Groups[i]
+		pkg := &args.Groups[i]
 		for j := range pkg.Versions {
 			ver := &pkg.Versions[j]
 			input := ver.Package
@@ -340,24 +340,22 @@ func sanitizePackagePaths(context *generator.Context, ca *clientgenargs.CustomAr
 }
 
 // GetTargets makes the client target definition.
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*clientgenargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
-	includedTypesOverrides := customArgs.IncludedTypesOverrides
+	includedTypesOverrides := args.IncludedTypesOverrides
 
-	if err := sanitizePackagePaths(context, customArgs); err != nil {
+	if err := sanitizePackagePaths(context, args); err != nil {
 		klog.Fatalf("cannot sanitize inputs: %v", err)
 	}
-	applyGroupOverrides(context.Universe, customArgs)
+	applyGroupOverrides(context.Universe, args)
 
 	gvToTypes := map[clientgentypes.GroupVersion][]*types.Type{}
 	groupGoNames := make(map[clientgentypes.GroupVersion]string)
-	for gv, inputDir := range customArgs.GroupVersionPackages() {
+	for gv, inputDir := range args.GroupVersionPackages() {
 		p := context.Universe.Package(inputDir)
 
 		// If there's a comment of the form "// +groupGoName=SomeUniqueShortName", use that as
@@ -395,28 +393,28 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 		}
 	}
 
-	clientsetDir := filepath.Join(customArgs.OutputDir, customArgs.ClientsetName)
+	clientsetDir := filepath.Join(args.OutputDir, args.ClientsetName)
-	clientsetPkg := filepath.Join(customArgs.OutputPkg, customArgs.ClientsetName)
+	clientsetPkg := filepath.Join(args.OutputPkg, args.ClientsetName)
 
 	var targetList []generator.Target
 
 	targetList = append(targetList,
-		targetForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
+		targetForClientset(args, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
 	targetList = append(targetList,
-		targetForScheme(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
+		targetForScheme(args, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
-	if customArgs.FakeClient {
+	if args.FakeClient {
 		targetList = append(targetList,
-			fake.TargetForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
+			fake.TargetForClientset(args, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
 	}
 
 	// If --clientset-only=true, we don't regenerate the individual typed clients.
-	if customArgs.ClientsetOnly {
+	if args.ClientsetOnly {
 		return []generator.Target(targetList)
 	}
 
 	orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
-	gvPackages := customArgs.GroupVersionPackages()
+	gvPackages := args.GroupVersionPackages()
-	for _, group := range customArgs.Groups {
+	for _, group := range args.Groups {
 		for _, version := range group.Versions {
 			gv := clientgentypes.GroupVersion{Group: group.Group, Version: version.Version}
 			types := gvToTypes[gv]
@@ -424,11 +422,11 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 			targetList = append(targetList,
 				targetForGroup(
 					gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg,
-					group.PackageName, groupGoNames[gv], customArgs.ClientsetAPIPath,
+					group.PackageName, groupGoNames[gv], args.ClientsetAPIPath,
-					inputPath, customArgs.ApplyConfigurationPackage, boilerplate))
+					inputPath, args.ApplyConfigurationPackage, boilerplate))
-			if customArgs.FakeClient {
+			if args.FakeClient {
 				targetList = append(targetList,
-					fake.TargetForGroup(gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg, group.PackageName, groupGoNames[gv], inputPath, customArgs.ApplyConfigurationPackage, boilerplate))
+					fake.TargetForGroup(gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg, group.PackageName, groupGoNames[gv], inputPath, args.ApplyConfigurationPackage, boilerplate))
 			}
 		}
 	}

staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/fake_client_generator.go

@@ -23,7 +23,7 @@ import (
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/types"
 
-	clientgenargs "k8s.io/code-generator/cmd/client-gen/args"
+	"k8s.io/code-generator/cmd/client-gen/args"
 	scheme "k8s.io/code-generator/cmd/client-gen/generators/scheme"
 	"k8s.io/code-generator/cmd/client-gen/generators/util"
 	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
@@ -87,7 +87,7 @@ func TargetForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clie
 	}
 }
 
-func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
+func TargetForClientset(args *args.Args, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
 	return &generator.SimpleTarget{
 		// TODO: we'll generate fake clientset for different release in the future.
 		// Package name and path are hard coded for now.
@@ -107,7 +107,7 @@ func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
 					GoGenerator: generator.GoGenerator{
 						OutputFilename: "clientset_generated.go",
 					},
-					groups:               customArgs.Groups,
+					groups:               args.Groups,
 					groupGoNames:         groupGoNames,
 					fakeClientsetPackage: clientsetPkg,
 					imports:              generator.NewImportTracker(),
@@ -117,9 +117,9 @@ func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
 					GoGenerator: generator.GoGenerator{
 						OutputFilename: "register.go",
 					},
-					InputPackages: customArgs.GroupVersionPackages(),
+					InputPackages: args.GroupVersionPackages(),
 					OutputPkg:     clientsetPkg,
-					Groups:        customArgs.Groups,
+					Groups:        args.Groups,
 					GroupGoNames:  groupGoNames,
 					ImportTracker: generator.NewImportTracker(),
 					PrivateScheme: true,

staging/src/k8s.io/code-generator/cmd/client-gen/main.go

@@ -23,39 +23,43 @@ import (
 	"github.com/spf13/pflag"
 	"k8s.io/klog/v2"
 
-	generatorargs "k8s.io/code-generator/cmd/client-gen/args"
+	"k8s.io/code-generator/cmd/client-gen/args"
 	"k8s.io/code-generator/cmd/client-gen/generators"
 	"k8s.io/code-generator/pkg/util"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of client-gen
-	customArgs.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of client-gen
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
 	// add group version package as input dirs for gengo
 	inputPkgs := []string{}
-	for _, pkg := range customArgs.Groups {
+	for _, pkg := range args.Groups {
 		for _, v := range pkg.Versions {
 			inputPkgs = append(inputPkgs, v.Package)
 		}
 	}
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
-	if err := genericArgs.Execute(
+	myTargets := func(context *generator.Context) []generator.Target {
-		generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
+		return generators.GetTargets(context, args)
+	}
+
+	if err := gengo.Execute(
+		generators.NameSystems(util.PluralExceptionListToMapOrDie(args.PluralExceptions)),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		inputPkgs,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/conversion-gen/args/args.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 )
 
 // DefaultBasePeerDirs are the peer-dirs nearly everybody will use, i.e. those coming from
@@ -31,8 +30,7 @@ var DefaultBasePeerDirs = []string{
 	"k8s.io/apimachinery/pkg/runtime",
 }
 
-// CustomArgs is used by the gengo framework to pass args specific to this generator.
+type Args struct {
-type CustomArgs struct {
 	// The filename of the generated results.
 	OutputFile string
 
@@ -61,40 +59,34 @@ type CustomArgs struct {
 	GoHeaderFile string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{
-	customArgs := &CustomArgs{
 		BasePeerDirs: DefaultBasePeerDirs,
 		SkipUnsafe:   false,
 	}
-	genericArgs.CustomArgs = customArgs
-	return genericArgs, customArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputFile, "output-file", "generated.conversion.go",
+	fs.StringVar(&args.OutputFile, "output-file", "generated.conversion.go",
 		"the name of the file to be generated")
-	fs.StringSliceVar(&ca.BasePeerDirs, "base-peer-dirs", ca.BasePeerDirs,
+	fs.StringSliceVar(&args.BasePeerDirs, "base-peer-dirs", args.BasePeerDirs,
 		"Comma-separated list of apimachinery import paths which are considered, after tag-specified peers, for conversions. Only change these if you have very good reasons.")
-	fs.StringSliceVar(&ca.ExtraPeerDirs, "extra-peer-dirs", ca.ExtraPeerDirs,
+	fs.StringSliceVar(&args.ExtraPeerDirs, "extra-peer-dirs", args.ExtraPeerDirs,
 		"Application specific comma-separated list of import paths which are considered, after tag-specified peers and base-peer-dirs, for conversions.")
-	fs.StringSliceVar(&ca.ExtraDirs, "extra-dirs", ca.ExtraDirs,
+	fs.StringSliceVar(&args.ExtraDirs, "extra-dirs", args.ExtraDirs,
 		"Application specific comma-separated list of import paths which are loaded and considered for callable conversions, but are not considered peers for conversion.")
-	fs.BoolVar(&ca.SkipUnsafe, "skip-unsafe", ca.SkipUnsafe,
+	fs.BoolVar(&args.SkipUnsafe, "skip-unsafe", args.SkipUnsafe,
 		"If true, will not generate code using unsafe pointer conversions; resulting code may be slower.")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	custom := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputFile) == 0 {
-
-	if len(custom.OutputFile) == 0 {
 		return fmt.Errorf("--output-file must be specified")
 	}
-
 	return nil
 }

staging/src/k8s.io/code-generator/cmd/conversion-gen/generators/conversion.go

@@ -25,14 +25,12 @@ import (
 	"sort"
 	"strings"
 
-	"k8s.io/gengo/v2/args"
+	"k8s.io/code-generator/cmd/conversion-gen/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
-
 	"k8s.io/klog/v2"
-
-	conversionargs "k8s.io/code-generator/cmd/conversion-gen/args"
 )
 
 // These are the comment tags that carry parameters for conversion generation.
@@ -197,10 +195,8 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package
 	}
 }
 
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*conversionargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
@@ -273,8 +269,8 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 	}
 
 	// Make sure explicit peer-packages are added.
-	peers := customArgs.BasePeerDirs
+	peers := args.BasePeerDirs
-	peers = append(peers, customArgs.ExtraPeerDirs...)
+	peers = append(peers, args.ExtraPeerDirs...)
 	if expanded, err := context.FindPackages(peers...); err != nil {
 		klog.Fatalf("cannot find peer packages: %v", err)
 	} else {
@@ -321,7 +317,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 		typesPkg = context.Universe[externalTypes]
 
 		unsafeEquality := TypesEqual(memoryEquivalentTypes)
-		if customArgs.SkipUnsafe {
+		if args.SkipUnsafe {
 			unsafeEquality = noEquality{}
 		}
 
@@ -336,7 +332,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 				},
 				GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 					return []generator.Generator{
-						NewGenConversion(customArgs.OutputFile, typesPkg.Path, pkg.Path, manualConversions, pkgToPeers[pkg.Path], unsafeEquality),
+						NewGenConversion(args.OutputFile, typesPkg.Path, pkg.Path, manualConversions, pkgToPeers[pkg.Path], unsafeEquality),
 					}
 				},
 			})

staging/src/k8s.io/code-generator/cmd/conversion-gen/main.go

@@ -102,29 +102,33 @@ import (
 
 	generatorargs "k8s.io/code-generator/cmd/conversion-gen/args"
 	"k8s.io/code-generator/cmd/conversion-gen/generators"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := generatorargs.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/deepcopy-gen/args/args.go

@@ -20,41 +20,33 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 )
 
-// CustomArgs is used by the gengo framework to pass args specific to this generator.
+type Args struct {
-type CustomArgs struct {
 	OutputFile   string
 	BoundingDirs []string // Only deal with types rooted under these dirs.
 	GoHeaderFile string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{}
-	customArgs := &CustomArgs{}
-	genericArgs.CustomArgs = (*CustomArgs)(customArgs) // convert to upstream type to make type-casts work there
-	return genericArgs, customArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputFile, "output-file", "generated.deepcopy.go",
+	fs.StringVar(&args.OutputFile, "output-file", "generated.deepcopy.go",
 		"the name of the file to be generated")
-	fs.StringSliceVar(&ca.BoundingDirs, "bounding-dirs", ca.BoundingDirs,
+	fs.StringSliceVar(&args.BoundingDirs, "bounding-dirs", args.BoundingDirs,
 		"Comma-separated list of import paths which bound the types for which deep-copies will be generated.")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	custom := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputFile) == 0 {
-
-	if len(custom.OutputFile) == 0 {
 		return fmt.Errorf("--output-file must be specified")
 	}
-
 	return nil
 }

staging/src/k8s.io/code-generator/cmd/deepcopy-gen/generators/deepcopy.go

@@ -23,8 +23,8 @@ import (
 	"sort"
 	"strings"
 
-	deepcopyargs "k8s.io/code-generator/cmd/deepcopy-gen/args"
+	"k8s.io/code-generator/cmd/deepcopy-gen/args"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
@@ -118,22 +118,20 @@ func DefaultNameSystem() string {
 	return "public"
 }
 
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*deepcopyargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
 	boundingDirs := []string{}
-	if customArgs.BoundingDirs == nil {
+	if args.BoundingDirs == nil {
-		customArgs.BoundingDirs = context.Inputs
+		args.BoundingDirs = context.Inputs
 	}
-	for i := range customArgs.BoundingDirs {
+	for i := range args.BoundingDirs {
 		// Strip any trailing slashes - they are not exactly "correct" but
 		// this is friendlier.
-		boundingDirs = append(boundingDirs, strings.TrimRight(customArgs.BoundingDirs[i], "/"))
+		boundingDirs = append(boundingDirs, strings.TrimRight(args.BoundingDirs[i], "/"))
 	}
 
 	targets := []generator.Target{}
@@ -198,7 +196,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 					},
 					GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 						return []generator.Generator{
-							NewGenDeepCopy(customArgs.OutputFile, pkg.Path, boundingDirs, (ptagValue == tagValuePackage), ptagRegister),
+							NewGenDeepCopy(args.OutputFile, pkg.Path, boundingDirs, (ptagValue == tagValuePackage), ptagRegister),
 						}
 					},
 				})

staging/src/k8s.io/code-generator/cmd/deepcopy-gen/main.go

@@ -72,32 +72,36 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	generatorargs "k8s.io/code-generator/cmd/deepcopy-gen/args"
+	"k8s.io/code-generator/cmd/deepcopy-gen/args"
 	"k8s.io/code-generator/cmd/deepcopy-gen/generators"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/defaulter-gen/args/args.go

@@ -20,39 +20,32 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 )
 
-// CustomArgs is used by the gengo framework to pass args specific to this generator.
+type Args struct {
-type CustomArgs struct {
 	OutputFile    string
 	ExtraPeerDirs []string // Always consider these as last-ditch possibilities for conversions.
 	GoHeaderFile  string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{}
-	customArgs := &CustomArgs{}
-	genericArgs.CustomArgs = (*CustomArgs)(customArgs) // convert to upstream type to make type-casts work there
-	return genericArgs, customArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputFile, "output-file", "generated.defaults.go",
+	fs.StringVar(&args.OutputFile, "output-file", "generated.defaults.go",
 		"the name of the file to be generated")
-	fs.StringSliceVar(&ca.ExtraPeerDirs, "extra-peer-dirs", ca.ExtraPeerDirs,
+	fs.StringSliceVar(&args.ExtraPeerDirs, "extra-peer-dirs", args.ExtraPeerDirs,
 		"Comma-separated list of import paths which are considered, after tag-specified peers, for conversions.")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	custom := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputFile) == 0 {
-
-	if len(custom.OutputFile) == 0 {
 		return fmt.Errorf("--output-file must be specified")
 	}
 

staging/src/k8s.io/code-generator/cmd/defaulter-gen/generators/defaulter.go

@@ -27,8 +27,8 @@ import (
 	"strconv"
 	"strings"
 
-	defaulterargs "k8s.io/code-generator/cmd/defaulter-gen/args"
+	"k8s.io/code-generator/cmd/defaulter-gen/args"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
@@ -221,10 +221,8 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package
 	}
 }
 
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*defaulterargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
@@ -275,7 +273,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 
 	// Make sure explicit peer-packages are added.
 	var peerPkgs []string
-	for _, pkg := range customArgs.ExtraPeerDirs {
+	for _, pkg := range args.ExtraPeerDirs {
 		// In case someone specifies a peer as a path into vendor, convert
 		// it to its "real" package path.
 		if i := strings.Index(pkg, "/vendor/"); i != -1 {
@@ -430,7 +428,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 
 				GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 					return []generator.Generator{
-						NewGenDefaulter(customArgs.OutputFile, typesPkg.Path, pkg.Path, existingDefaulters, newDefaulters, peerPkgs),
+						NewGenDefaulter(args.OutputFile, typesPkg.Path, pkg.Path, existingDefaulters, newDefaulters, peerPkgs),
 					}
 				},
 			})

staging/src/k8s.io/code-generator/cmd/defaulter-gen/main.go

@@ -45,32 +45,36 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	generatorargs "k8s.io/code-generator/cmd/defaulter-gen/args"
+	"k8s.io/code-generator/cmd/defaulter-gen/args"
 	"k8s.io/code-generator/cmd/defaulter-gen/generators"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/informer-gen/args/args.go

@@ -20,11 +20,10 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 )
 
-// CustomArgs is used by the gengo framework to pass args specific to this generator.
+// Args is used by the gengo framework to pass args specific to this generator.
-type CustomArgs struct {
+type Args struct {
 	OutputDir                 string // must be a directory path
 	OutputPkg                 string // must be a Go import-path
 	GoHeaderFile              string
@@ -38,49 +37,47 @@ type CustomArgs struct {
 	PluralExceptions []string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{
-	customArgs := &CustomArgs{
 		SingleDirectory:  false,
 		PluralExceptions: []string{"Endpoints:Endpoints"},
 	}
-	genericArgs.CustomArgs = customArgs
-
-	return genericArgs, customArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputDir, "output-dir", "",
+	fs.StringVar(&args.OutputDir, "output-dir", "",
 		"the base directory under which to generate results")
-	fs.StringVar(&ca.OutputPkg, "output-pkg", ca.OutputPkg,
+	fs.StringVar(&args.OutputPkg, "output-pkg", args.OutputPkg,
 		"the Go import-path of the generated results")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
-	fs.StringVar(&ca.InternalClientSetPackage, "internal-clientset-package", ca.InternalClientSetPackage, "the Go import-path of the internal clientset to use")
+	fs.StringVar(&args.InternalClientSetPackage, "internal-clientset-package", args.InternalClientSetPackage,
-	fs.StringVar(&ca.VersionedClientSetPackage, "versioned-clientset-package", ca.VersionedClientSetPackage, "the Go import-path of the versioned clientset to use")
+		"the Go import-path of the internal clientset to use")
-	fs.StringVar(&ca.ListersPackage, "listers-package", ca.ListersPackage, "the Go import-path of the listers to use")
+	fs.StringVar(&args.VersionedClientSetPackage, "versioned-clientset-package", args.VersionedClientSetPackage,
-	fs.BoolVar(&ca.SingleDirectory, "single-directory", ca.SingleDirectory, "if true, omit the intermediate \"internalversion\" and \"externalversions\" subdirectories")
+		"the Go import-path of the versioned clientset to use")
-	fs.StringSliceVar(&ca.PluralExceptions, "plural-exceptions", ca.PluralExceptions, "list of comma separated plural exception definitions in Type:PluralizedType format")
+	fs.StringVar(&args.ListersPackage, "listers-package", args.ListersPackage,
+		"the Go import-path of the listers to use")
+	fs.BoolVar(&args.SingleDirectory, "single-directory", args.SingleDirectory,
+		"if true, omit the intermediate \"internalversion\" and \"externalversions\" subdirectories")
+	fs.StringSliceVar(&args.PluralExceptions, "plural-exceptions", args.PluralExceptions,
+		"list of comma separated plural exception definitions in Type:PluralizedType format")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	customArgs := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputDir) == 0 {
-
-	if len(customArgs.OutputDir) == 0 {
 		return fmt.Errorf("--output-dir must be specified")
 	}
-	if len(customArgs.OutputPkg) == 0 {
+	if len(args.OutputPkg) == 0 {
 		return fmt.Errorf("--output-pkg must be specified")
 	}
-	if len(customArgs.VersionedClientSetPackage) == 0 {
+	if len(args.VersionedClientSetPackage) == 0 {
 		return fmt.Errorf("--versioned-clientset-package must be specified")
 	}
-	if len(customArgs.ListersPackage) == 0 {
+	if len(args.ListersPackage) == 0 {
 		return fmt.Errorf("--listers-package must be specified")
 	}
-
 	return nil
 }

staging/src/k8s.io/code-generator/cmd/informer-gen/generators/targets.go

@@ -22,16 +22,15 @@ import (
 	"path/filepath"
 	"strings"
 
-	"k8s.io/gengo/v2/args"
+	"k8s.io/code-generator/cmd/client-gen/generators/util"
+	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
+	"k8s.io/code-generator/cmd/informer-gen/args"
+	genutil "k8s.io/code-generator/pkg/util"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
 	"k8s.io/klog/v2"
-
-	"k8s.io/code-generator/cmd/client-gen/generators/util"
-	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
-	informergenargs "k8s.io/code-generator/cmd/informer-gen/args"
-	genutil "k8s.io/code-generator/pkg/util"
 )
 
 // NameSystems returns the name system used by the generators in this package.
@@ -93,19 +92,17 @@ func subdirForInternalInterfaces(base string) string {
 }
 
 // GetTargets makes the client target definition.
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*informergenargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
-	internalVersionOutputDir := customArgs.OutputDir
+	internalVersionOutputDir := args.OutputDir
-	internalVersionOutputPkg := customArgs.OutputPkg
+	internalVersionOutputPkg := args.OutputPkg
-	externalVersionOutputDir := customArgs.OutputDir
+	externalVersionOutputDir := args.OutputDir
-	externalVersionOutputPkg := customArgs.OutputPkg
+	externalVersionOutputPkg := args.OutputPkg
-	if !customArgs.SingleDirectory {
+	if !args.SingleDirectory {
 		internalVersionOutputDir = filepath.Join(internalVersionOutputDir, "internalversion")
 		internalVersionOutputPkg = filepath.Join(internalVersionOutputPkg, "internalversion")
 		externalVersionOutputDir = filepath.Join(externalVersionOutputDir, "externalversions")
@@ -200,14 +197,14 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 					internalVersionOutputDir, internalVersionOutputPkg,
 					groupPackageName, gv, groupGoNames[groupPackageName],
 					boilerplate, typesToGenerate,
-					customArgs.InternalClientSetPackage, customArgs.ListersPackage))
+					args.InternalClientSetPackage, args.ListersPackage))
 		} else {
 			targetList = append(targetList,
 				versionTarget(
 					externalVersionOutputDir, externalVersionOutputPkg,
 					groupPackageName, gv, groupGoNames[groupPackageName],
 					boilerplate, typesToGenerate,
-					customArgs.VersionedClientSetPackage, customArgs.ListersPackage))
+					args.VersionedClientSetPackage, args.ListersPackage))
 		}
 	}
 
@@ -215,12 +212,12 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 		targetList = append(targetList,
 			factoryInterfaceTarget(
 				externalVersionOutputDir, externalVersionOutputPkg,
-				boilerplate, customArgs.VersionedClientSetPackage))
+				boilerplate, args.VersionedClientSetPackage))
 		targetList = append(targetList,
 			factoryTarget(
 				externalVersionOutputDir, externalVersionOutputPkg,
-				boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(customArgs.PluralExceptions),
+				boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(args.PluralExceptions),
-				externalGroupVersions, customArgs.VersionedClientSetPackage, typesForGroupVersion))
+				externalGroupVersions, args.VersionedClientSetPackage, typesForGroupVersion))
 		for _, gvs := range externalGroupVersions {
 			targetList = append(targetList,
 				groupTarget(externalVersionOutputDir, externalVersionOutputPkg, gvs, boilerplate))
@@ -229,12 +226,12 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 
 	if len(internalGroupVersions) != 0 {
 		targetList = append(targetList,
-			factoryInterfaceTarget(internalVersionOutputDir, internalVersionOutputPkg, boilerplate, customArgs.InternalClientSetPackage))
+			factoryInterfaceTarget(internalVersionOutputDir, internalVersionOutputPkg, boilerplate, args.InternalClientSetPackage))
 		targetList = append(targetList,
 			factoryTarget(
 				internalVersionOutputDir, internalVersionOutputPkg,
-				boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(customArgs.PluralExceptions),
+				boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(args.PluralExceptions),
-				internalGroupVersions, customArgs.InternalClientSetPackage, typesForGroupVersion))
+				internalGroupVersions, args.InternalClientSetPackage, typesForGroupVersion))
 		for _, gvs := range internalGroupVersions {
 			targetList = append(targetList,
 				groupTarget(internalVersionOutputDir, internalVersionOutputPkg, gvs, boilerplate))

staging/src/k8s.io/code-generator/cmd/informer-gen/main.go

@@ -20,33 +20,37 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	generatorargs "k8s.io/code-generator/cmd/informer-gen/args"
+	"k8s.io/code-generator/cmd/informer-gen/args"
 	"k8s.io/code-generator/cmd/informer-gen/generators"
 	"k8s.io/code-generator/pkg/util"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
-		generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
+		generators.NameSystems(util.PluralExceptionListToMapOrDie(args.PluralExceptions)),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/lister-gen/args/args.go

@@ -20,11 +20,10 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 )
 
-// CustomArgs is used by the gengo framework to pass args specific to this generator.
+// Args is used by the gengo framework to pass args specific to this generator.
-type CustomArgs struct {
+type Args struct {
 	OutputDir    string // must be a directory path
 	OutputPkg    string // must be a Go import-path
 	GoHeaderFile string
@@ -34,39 +33,32 @@ type CustomArgs struct {
 	PluralExceptions []string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{
-	customArgs := &CustomArgs{
 		PluralExceptions: []string{"Endpoints:Endpoints"},
 	}
-	genericArgs.CustomArgs = customArgs
-
-	return genericArgs, customArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputDir, "output-dir", "",
+	fs.StringVar(&args.OutputDir, "output-dir", "",
 		"the base directory under which to generate results")
-	fs.StringVar(&ca.OutputPkg, "output-pkg", "",
+	fs.StringVar(&args.OutputPkg, "output-pkg", "",
 		"the base Go import-path under which to generate results")
-	fs.StringSliceVar(&ca.PluralExceptions, "plural-exceptions", ca.PluralExceptions,
+	fs.StringSliceVar(&args.PluralExceptions, "plural-exceptions", args.PluralExceptions,
 		"list of comma separated plural exception definitions in Type:PluralizedType format")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	custom := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputDir) == 0 {
-
-	if len(custom.OutputDir) == 0 {
 		return fmt.Errorf("--output-dir must be specified")
 	}
-	if len(custom.OutputPkg) == 0 {
+	if len(args.OutputPkg) == 0 {
 		return fmt.Errorf("--output-pkg must be specified")
 	}
-
 	return nil
 }

staging/src/k8s.io/code-generator/cmd/lister-gen/generators/lister.go

@@ -24,8 +24,8 @@ import (
 
 	"k8s.io/code-generator/cmd/client-gen/generators/util"
 	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
-	listergenargs "k8s.io/code-generator/cmd/lister-gen/args"
+	"k8s.io/code-generator/cmd/lister-gen/args"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
@@ -59,10 +59,8 @@ func DefaultNameSystem() string {
 }
 
 // GetTargets makes the client target definition.
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*listergenargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
@@ -121,8 +119,8 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 		typesToGenerate = orderer.OrderTypes(typesToGenerate)
 
 		subdir := filepath.Join(groupPackageName, strings.ToLower(gv.Version.NonEmpty()))
-		outputDir := filepath.Join(customArgs.OutputDir, subdir)
+		outputDir := filepath.Join(args.OutputDir, subdir)
-		outputPkg := filepath.Join(customArgs.OutputPkg, subdir)
+		outputPkg := filepath.Join(args.OutputPkg, subdir)
 		targetList = append(targetList, &generator.SimpleTarget{
 			PkgName:       strings.ToLower(gv.Version.NonEmpty()),
 			PkgPath:       outputPkg,

staging/src/k8s.io/code-generator/cmd/lister-gen/main.go

@@ -20,33 +20,37 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	generatorargs "k8s.io/code-generator/cmd/lister-gen/args"
+	"k8s.io/code-generator/cmd/lister-gen/args"
 	"k8s.io/code-generator/cmd/lister-gen/generators"
 	"k8s.io/code-generator/pkg/util"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
-		generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
+		generators.NameSystems(util.PluralExceptionListToMapOrDie(args.PluralExceptions)),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/openapi-gen/main.go

@@ -25,32 +25,36 @@ import (
 	"log"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
-	generatorargs "k8s.io/kube-openapi/cmd/openapi-gen/args"
+	"k8s.io/kube-openapi/cmd/openapi-gen/args"
 	"k8s.io/kube-openapi/pkg/generators"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		log.Fatalf("Arguments validation error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
 	// Generates the code for the OpenAPIDefinitions.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		log.Fatalf("OpenAPI code generation error: %v", err)

staging/src/k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args/args.go

@@ -20,34 +20,29 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	statusgenerators "k8s.io/code-generator/cmd/prerelease-lifecycle-gen/prerelease-lifecycle-generators"
-	"k8s.io/gengo/v2/args"
 )
 
-// CustomArgs is used by the gengo framework to pass args specific to this generator.
+type Args struct {
-type CustomArgs statusgenerators.CustomArgs
+	OutputFile   string
+	GoHeaderFile string
+}
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{}
-	customArgs := &CustomArgs{}
-	genericArgs.CustomArgs = (*statusgenerators.CustomArgs)(customArgs) // convert to upstream type to make type-casts work there
-	return genericArgs, customArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputFile, "output-file", "generated.prerelease_lifecycle.go",
+	fs.StringVar(&args.OutputFile, "output-file", "generated.prerelease_lifecycle.go",
 		"the name of the file to be generated")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	custom := genericArgs.CustomArgs.(*statusgenerators.CustomArgs)
+	if len(args.OutputFile) == 0 {
-
-	if len(custom.OutputFile) == 0 {
 		return fmt.Errorf("--output-file must be specified")
 	}
 

staging/src/k8s.io/code-generator/cmd/prerelease-lifecycle-gen/main.go

@@ -38,32 +38,36 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	generatorargs "k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args"
+	"k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args"
 	statusgenerators "k8s.io/code-generator/cmd/prerelease-lifecycle-gen/prerelease-lifecycle-generators"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs, customArgs := generatorargs.NewDefaults()
+	args := args.New()
 
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
-	customArgs.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	pflag.Parse()
 
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
+	myTargets := func(context *generator.Context) []generator.Target {
+		return statusgenerators.GetTargets(context, args)
+	}
+
 	// Run it.
-	if err := genericArgs.Execute(
+	if err := gengo.Execute(
 		statusgenerators.NameSystems(),
 		statusgenerators.DefaultNameSystem(),
-		statusgenerators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)

staging/src/k8s.io/code-generator/cmd/prerelease-lifecycle-gen/prerelease-lifecycle-generators/status.go

@@ -23,7 +23,8 @@ import (
 	"strconv"
 	"strings"
 
-	"k8s.io/gengo/v2/args"
+	"k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
@@ -31,12 +32,6 @@ import (
 	"k8s.io/klog/v2"
 )
 
-// CustomArgs is used tby the go2idl framework to pass args specific to this generator.
-type CustomArgs struct {
-	OutputFile   string
-	GoHeaderFile string
-}
-
 // This is the comment tag that carries parameters for API status generation.  Because the cadence is fixed, we can predict
 // with near certainty when this lifecycle happens as the API is introduced.
 const (
@@ -182,10 +177,8 @@ func DefaultNameSystem() string {
 }
 
 // GetTargets makes the target definition.
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
@@ -244,7 +237,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 					},
 					GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 						return []generator.Generator{
-							NewPrereleaseLifecycleGen(customArgs.OutputFile, pkg.Path),
+							NewPrereleaseLifecycleGen(args.OutputFile, pkg.Path),
 						}
 					},
 				})

staging/src/k8s.io/code-generator/cmd/register-gen/args/args.go

@@ -20,33 +20,29 @@ import (
 	"fmt"
 
 	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2/args"
 )
 
-type CustomArgs struct {
+type Args struct {
 	OutputFile   string
 	GoHeaderFile string
 }
 
-// NewDefaults returns default arguments for the generator.
+// New returns default arguments for the generator.
-func NewDefaults() *args.GeneratorArgs {
+func New() *Args {
-	genericArgs := args.Default()
+	return &Args{}
-	genericArgs.CustomArgs = &CustomArgs{}
-	return genericArgs
 }
 
 // AddFlags add the generator flags to the flag set.
-func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
+func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&ca.OutputFile, "output-file", "generated.register.go",
+	fs.StringVar(&args.OutputFile, "output-file", "generated.register.go",
 		"the name of the file to be generated")
-	fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
+	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
 		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
 }
 
 // Validate checks the given arguments.
-func Validate(genericArgs *args.GeneratorArgs) error {
+func (args *Args) Validate() error {
-	custom := genericArgs.CustomArgs.(*CustomArgs)
+	if len(args.OutputFile) == 0 {
-	if len(custom.OutputFile) == 0 {
 		return fmt.Errorf("output file base name cannot be empty")
 	}
 

staging/src/k8s.io/code-generator/cmd/register-gen/generators/targets.go

@@ -25,8 +25,8 @@ import (
 	"k8s.io/klog/v2"
 
 	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
-	registerargs "k8s.io/code-generator/cmd/register-gen/args"
+	"k8s.io/code-generator/cmd/register-gen/args"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
 	"k8s.io/gengo/v2/generator"
 	"k8s.io/gengo/v2/namer"
 	"k8s.io/gengo/v2/types"
@@ -44,10 +44,8 @@ func DefaultNameSystem() string {
 }
 
 // GetTargets makes targets to generate.
-func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
+func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	customArgs := arguments.CustomArgs.(*registerargs.CustomArgs)
+	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
-
-	boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
@@ -57,17 +55,17 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 		pkg := context.Universe.Package(input)
 		internal, err := isInternal(pkg)
 		if err != nil {
-			klog.V(5).Infof("skipping the generation of %s file, due to err %v", customArgs.OutputFile, err)
+			klog.V(5).Infof("skipping the generation of %s file, due to err %v", args.OutputFile, err)
 			continue
 		}
 		if internal {
-			klog.V(5).Infof("skipping the generation of %s file because %s package contains internal types, note that internal types don't have \"json\" tags", customArgs.OutputFile, pkg.Name)
+			klog.V(5).Infof("skipping the generation of %s file because %s package contains internal types, note that internal types don't have \"json\" tags", args.OutputFile, pkg.Name)
 			continue
 		}
 		registerFileName := "register.go"
 		searchPath := path.Join(pkg.SourcePath, registerFileName)
 		if _, err := os.Stat(path.Join(searchPath)); err == nil {
-			klog.V(5).Infof("skipping the generation of %s file because %s already exists in the path %s", customArgs.OutputFile, registerFileName, searchPath)
+			klog.V(5).Infof("skipping the generation of %s file because %s already exists in the path %s", args.OutputFile, registerFileName, searchPath)
 			continue
 		} else if err != nil && !os.IsNotExist(err) {
 			klog.Fatalf("an error %v has occurred while checking if %s exists", err, registerFileName)
@@ -112,7 +110,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
 					return []generator.Generator{
 						&registerExternalGenerator{
 							GoGenerator: generator.GoGenerator{
-								OutputFilename: customArgs.OutputFile,
+								OutputFilename: args.OutputFile,
 							},
 							gv:              gv,
 							typesToGenerate: typesToRegister,

staging/src/k8s.io/code-generator/cmd/register-gen/main.go

@@ -20,29 +20,34 @@ import (
 	"flag"
 
 	"github.com/spf13/pflag"
-	generatorargs "k8s.io/code-generator/cmd/register-gen/args"
+	"k8s.io/code-generator/cmd/register-gen/args"
 	"k8s.io/code-generator/cmd/register-gen/generators"
-	"k8s.io/gengo/v2/args"
+	gengo "k8s.io/gengo/v2/args"
+	"k8s.io/gengo/v2/generator"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	genericArgs := generatorargs.NewDefaults()
+	args := args.New()
-	genericArgs.AddFlags(pflag.CommandLine)
+	args.AddFlags(pflag.CommandLine)
 	flag.Set("logtostderr", "true")
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 
 	pflag.Parse()
-	if err := generatorargs.Validate(genericArgs); err != nil {
+	if err := args.Validate(); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}
 
-	if err := genericArgs.Execute(
+	myTargets := func(context *generator.Context) []generator.Target {
+		return generators.GetTargets(context, args)
+	}
+
+	if err := gengo.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.GetTargets,
+		myTargets,
-		args.StdBuildTag,
+		gengo.StdBuildTag,
 		pflag.Args(),
 	); err != nil {
 		klog.Fatalf("Error: %v", err)