Rename gengo generator.Package -> Target

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

@@ -54,8 +54,8 @@ func DefaultNameSystem() string {
 	return "public"
 }
 
-// Packages makes the client package definition.
+// GetTargets makes the client target definition.
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
@@ -75,7 +75,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 	groupGoNames := make(map[string]string)
 	applyConfigsForGroupVersion := make(map[clientgentypes.GroupVersion][]applyConfig)
 
-	var packageList []generator.Package
+	var targetList []generator.Target
 	for pkg, p := range pkgTypes {
 		gv := groupVersion(p)
 
@@ -107,8 +107,8 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		pkgSubdir := strings.TrimPrefix(pkg, customArgs.OutputPackage+"/")
 
 		// generate the apply configurations
-		packageList = append(packageList,
+		targetList = append(targetList,
-			generatorForApplyConfigurationsPackage(
+			targetForApplyConfigurationsPackage(
 				arguments.OutputBase, customArgs.OutputPackage, pkgSubdir,
 				boilerplate, gv, toGenerate, refs, typeModels))
 
@@ -132,15 +132,15 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 	}
 
 	// generate ForKind() utility function
-	packageList = append(packageList,
+	targetList = append(targetList,
-		generatorForUtils(arguments.OutputBase, customArgs.OutputPackage,
+		targetForUtils(arguments.OutputBase, customArgs.OutputPackage,
 			boilerplate, groupVersions, applyConfigsForGroupVersion, groupGoNames))
 	// generate internal embedded schema, required for generated Extract functions
-	packageList = append(packageList,
+	targetList = append(targetList,
-		generatorForInternal(arguments.OutputBase, customArgs.OutputPackage,
+		targetForInternal(arguments.OutputBase, customArgs.OutputPackage,
 			boilerplate, typeModels))
 
-	return packageList
+	return targetList
 }
 
 func friendlyName(name string) string {
@@ -161,11 +161,11 @@ func typeName(t *types.Type) string {
 	return fmt.Sprintf("%s.%s", typePackage, t.Name.Name)
 }
 
-func generatorForApplyConfigurationsPackage(outputDirBase, outputPkgBase, pkgSubdir string, boilerplate []byte, gv clientgentypes.GroupVersion, typesToGenerate []applyConfig, refs refGraph, models *typeModels) generator.Package {
+func targetForApplyConfigurationsPackage(outputDirBase, outputPkgBase, pkgSubdir string, boilerplate []byte, gv clientgentypes.GroupVersion, typesToGenerate []applyConfig, refs refGraph, models *typeModels) generator.Target {
 	outputDir := filepath.Join(outputDirBase, pkgSubdir)
 	outputPkg := filepath.Join(outputPkgBase, pkgSubdir)
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       gv.Version.PackageName(),
 		PkgPath:       outputPkg,
 		PkgDir:        outputDir,
@@ -199,8 +199,8 @@ func generatorForApplyConfigurationsPackage(outputDirBase, outputPkgBase, pkgSub
 	}
 }
 
-func generatorForUtils(outputDirBase, outputPkgBase string, boilerplate []byte, groupVersions map[string]clientgentypes.GroupVersions, applyConfigsForGroupVersion map[clientgentypes.GroupVersion][]applyConfig, groupGoNames map[string]string) generator.Package {
+func targetForUtils(outputDirBase, outputPkgBase string, boilerplate []byte, groupVersions map[string]clientgentypes.GroupVersions, applyConfigsForGroupVersion map[clientgentypes.GroupVersion][]applyConfig, groupGoNames map[string]string) generator.Target {
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       filepath.Base(outputPkgBase),
 		PkgPath:       outputPkgBase,
 		PkgDir:        outputDirBase,
@@ -221,10 +221,10 @@ func generatorForUtils(outputDirBase, outputPkgBase string, boilerplate []byte,
 	}
 }
 
-func generatorForInternal(outputDirBase, outputPkgBase string, boilerplate []byte, models *typeModels) generator.Package {
+func targetForInternal(outputDirBase, outputPkgBase string, boilerplate []byte, models *typeModels) generator.Target {
 	outputDir := filepath.Join(outputDirBase, "internal")
 	outputPkg := filepath.Join(outputPkgBase, "internal")
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       filepath.Base(outputPkg),
 		PkgPath:       outputPkg,
 		PkgDir:        outputDir,

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

@@ -46,7 +46,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -127,12 +127,12 @@ func DefaultNameSystem() string {
 	return "public"
 }
 
-func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetDir, clientsetPkg string, groupPkgName string, groupGoName string, apiPath string, inputPkg string, applyBuilderPkg string, boilerplate []byte) generator.Package {
+func targetForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetDir, clientsetPkg string, groupPkgName string, groupGoName string, apiPath string, inputPkg string, applyBuilderPkg string, boilerplate []byte) generator.Target {
 	subdir := filepath.Join("typed", strings.ToLower(groupPkgName), strings.ToLower(gv.Version.NonEmpty()))
 	gvDir := filepath.Join(clientsetDir, subdir)
 	gvPkg := filepath.Join(clientsetPkg, subdir)
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       strings.ToLower(gv.Version.NonEmpty()),
 		PkgPath:       gvPkg,
 		PkgDir:        gvDir,
@@ -196,8 +196,8 @@ func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli
 	}
 }
 
-func packageForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package {
+func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       customArgs.ClientsetName,
 		PkgPath:       clientsetPkg,
 		PkgDir:        clientsetDir,
@@ -221,7 +221,7 @@ func packageForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, cli
 	}
 }
 
-func packageForScheme(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package {
+func targetForScheme(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
 	schemeDir := filepath.Join(clientsetDir, "scheme")
 	schemePkg := filepath.Join(clientsetPkg, "scheme")
 
@@ -237,7 +237,7 @@ NextGroup:
 		}
 	}
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       "scheme",
 		PkgPath:       schemePkg,
 		PkgDir:        schemeDir,
@@ -339,8 +339,8 @@ func sanitizePackagePaths(context *generator.Context, ca *clientgenargs.CustomAr
 	return nil
 }
 
-// Packages makes the client package definition.
+// GetTargets makes the client target definition.
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
@@ -400,20 +400,20 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 	clientsetDir := filepath.Join(arguments.OutputBase, customArgs.ClientsetName)
 	clientsetPkg := filepath.Join(customArgs.OutputPackage, customArgs.ClientsetName)
 
-	var packageList []generator.Package
+	var targetList []generator.Target
 
-	packageList = append(packageList,
+	targetList = append(targetList,
-		packageForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
+		targetForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
-	packageList = append(packageList,
+	targetList = append(targetList,
-		packageForScheme(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
+		targetForScheme(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
 	if customArgs.FakeClient {
-		packageList = append(packageList,
+		targetList = append(targetList,
-			fake.PackageForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
+			fake.TargetForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
 	}
 
 	// If --clientset-only=true, we don't regenerate the individual typed clients.
 	if customArgs.ClientsetOnly {
-		return []generator.Package(packageList)
+		return []generator.Target(targetList)
 	}
 
 	orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
@@ -423,17 +423,17 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 			gv := clientgentypes.GroupVersion{Group: group.Group, Version: version.Version}
 			types := gvToTypes[gv]
 			inputPath := gvPackages[gv]
-			packageList = append(packageList,
+			targetList = append(targetList,
-				packageForGroup(
+				targetForGroup(
 					gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg,
 					group.PackageName, groupGoNames[gv], customArgs.ClientsetAPIPath,
 					inputPath, customArgs.ApplyConfigurationPackage, boilerplate))
 			if customArgs.FakeClient {
-				packageList = append(packageList,
+				targetList = append(targetList,
-					fake.PackageForGroup(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, customArgs.ApplyConfigurationPackage, boilerplate))
 			}
 		}
 	}
 
-	return []generator.Package(packageList)
+	return targetList
 }

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

@@ -29,14 +29,14 @@ import (
 	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
 )
 
-func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetDir, clientsetPkg string, groupPkgName string, groupGoName string, inputPkg string, applyBuilderPackage string, boilerplate []byte) generator.Package {
+func TargetForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetDir, clientsetPkg string, groupPkgName string, groupGoName string, inputPkg string, applyBuilderPackage string, boilerplate []byte) generator.Target {
 	// TODO: should make this a function, called by here and in client-generator.go
 	subdir := filepath.Join("typed", strings.ToLower(groupPkgName), strings.ToLower(gv.Version.NonEmpty()))
 	outputDir := filepath.Join(clientsetDir, subdir, "fake")
 	outputPkg := filepath.Join(clientsetPkg, subdir, "fake")
 	realClientPkg := filepath.Join(clientsetPkg, subdir)
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       "fake",
 		PkgPath:       outputPkg,
 		PkgDir:        outputDir,
@@ -87,8 +87,8 @@ func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli
 	}
 }
 
-func PackageForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package {
+func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		// TODO: we'll generate fake clientset for different release in the future.
 		// Package name and path are hard coded for now.
 		PkgName:       "fake",

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

@@ -52,7 +52,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -197,13 +197,13 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package
 	}
 }
 
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
-	packages := []generator.Package{}
+	targets := []generator.Target{}
 	header := append([]byte(fmt.Sprintf("// +build !%s\n\n", arguments.GeneratedBuildTag)), boilerplate...)
 
 	// Accumulate pre-existing conversion functions.
@@ -330,8 +330,8 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 			unsafeEquality = noEquality{}
 		}
 
-		packages = append(packages,
+		targets = append(targets,
-			&generator.SimplePackage{
+			&generator.SimpleTarget{
 				PkgName:       filepath.Base(pkg.Path),
 				PkgPath:       pkg.Path,
 				PkgDir:        pkg.SourcePath, // output pkg is the same as the input
@@ -358,7 +358,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		memoryEquivalentTypes.Skip(k.inType, k.outType)
 	}
 
-	return packages
+	return targets
 }
 
 type equalMemoryTypes map[conversionPair]bool

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

@@ -131,7 +131,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -73,7 +73,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -69,7 +69,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

staging/src/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/cmd.go

@@ -184,7 +184,7 @@ func Run(g *Generator) {
 	}
 
 	protobufNames := NewProtobufNamer()
-	outputPackages := []generator.Package{}
+	outputPackages := []generator.Target{}
 	nonOutputPackages := map[string]struct{}{}
 
 	for _, input := range c.Inputs {
@@ -230,7 +230,7 @@ func Run(g *Generator) {
 	}
 	sort.Sort(positionOrder{topologicalPos, protobufNames.packages})
 
-	var localOutputPackages []generator.Package
+	var localOutputPackages []generator.Target
 	for _, p := range protobufNames.packages {
 		if _, ok := nonOutputPackages[p.Name()]; ok {
 			// if we're not outputting the package, don't include it in either package list
@@ -243,7 +243,7 @@ func Run(g *Generator) {
 		log.Fatalf("Failed to identify Common types: %v", err)
 	}
 
-	if err := c.ExecutePackages(localOutputPackages); err != nil {
+	if err := c.ExecuteTargets(localOutputPackages); err != nil {
 		log.Fatalf("Failed executing local generator: %v", err)
 	}
 
@@ -337,7 +337,7 @@ func Run(g *Generator) {
 			p := outputPackage.(*protobufPackage)
 			p.OmitGogo = true
 		}
-		if err := c.ExecutePackages(localOutputPackages); err != nil {
+		if err := c.ExecuteTargets(localOutputPackages); err != nil {
 			log.Fatalf("Failed executing local generator: %v", err)
 		}
 	}

staging/src/k8s.io/code-generator/cmd/go-to-protobuf/protobuf/package.go

@@ -31,7 +31,7 @@ import (
 
 func newProtobufPackage(packagePath, packageDir, packageName string, generateAll bool, omitFieldTypes map[types.Name]struct{}) *protobufPackage {
 	pkg := &protobufPackage{
-		SimplePackage: generator.SimplePackage{
+		SimpleTarget: generator.SimpleTarget{
 			// The protobuf package name (foo.bar.baz)
 			PkgName:       packageName,
 			PkgPath:       packagePath,
@@ -49,7 +49,7 @@ func newProtobufPackage(packagePath, packageDir, packageName string, generateAll
 
 // protobufPackage contains the protobuf implementation of Package.
 type protobufPackage struct {
-	generator.SimplePackage
+	generator.SimpleTarget
 
 	// If true, generate protobuf serializations for all public types.
 	// If false, only generate protobuf serializations for structs that
@@ -201,5 +201,5 @@ func (p *protobufPackage) OutputPath() string {
 }
 
 var (
-	_ = generator.Package(&protobufPackage{})
+	_ = generator.Target(&protobufPackage{})
 )

staging/src/k8s.io/code-generator/cmd/import-boss/main.go

@@ -36,7 +36,7 @@ func main() {
 	if err := arguments.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Errorf("Error: %v", err)
 		os.Exit(1)

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

@@ -92,8 +92,8 @@ func subdirForInternalInterfaces(base string) string {
 	return filepath.Join(base, "internalinterfaces")
 }
 
-// Packages makes the client package definition.
+// GetTargets makes the client target definition.
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
@@ -115,7 +115,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		externalVersionOutputPkg = filepath.Join(externalVersionOutputPkg, "externalversions")
 	}
 
-	var packageList []generator.Package
+	var targetList []generator.Target
 	typesForGroupVersion := make(map[clientgentypes.GroupVersion][]*types.Type)
 
 	externalGroupVersions := make(map[string]clientgentypes.GroupVersions)
@@ -198,15 +198,15 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		typesToGenerate = orderer.OrderTypes(typesToGenerate)
 
 		if internal {
-			packageList = append(packageList,
+			targetList = append(targetList,
-				versionPackage(
+				versionTarget(
 					internalVersionOutputDir, internalVersionOutputPkg,
 					groupPackageName, gv, groupGoNames[groupPackageName],
 					boilerplate, typesToGenerate,
 					customArgs.InternalClientSetPackage, customArgs.ListersPackage))
 		} else {
-			packageList = append(packageList,
+			targetList = append(targetList,
-				versionPackage(
+				versionTarget(
 					externalVersionOutputDir, externalVersionOutputPkg,
 					groupPackageName, gv, groupGoNames[groupPackageName],
 					boilerplate, typesToGenerate,
@@ -215,41 +215,41 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 	}
 
 	if len(externalGroupVersions) != 0 {
-		packageList = append(packageList,
+		targetList = append(targetList,
-			factoryInterfacePackage(
+			factoryInterfaceTarget(
 				externalVersionOutputDir, externalVersionOutputPkg,
 				boilerplate, customArgs.VersionedClientSetPackage))
-		packageList = append(packageList,
+		targetList = append(targetList,
-			factoryPackage(
+			factoryTarget(
 				externalVersionOutputDir, externalVersionOutputPkg,
 				boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(customArgs.PluralExceptions),
 				externalGroupVersions, customArgs.VersionedClientSetPackage, typesForGroupVersion))
 		for _, gvs := range externalGroupVersions {
-			packageList = append(packageList,
+			targetList = append(targetList,
-				groupPackage(externalVersionOutputDir, externalVersionOutputPkg, gvs, boilerplate))
+				groupTarget(externalVersionOutputDir, externalVersionOutputPkg, gvs, boilerplate))
 		}
 	}
 
 	if len(internalGroupVersions) != 0 {
-		packageList = append(packageList,
+		targetList = append(targetList,
-			factoryInterfacePackage(internalVersionOutputDir, internalVersionOutputPkg, boilerplate, customArgs.InternalClientSetPackage))
+			factoryInterfaceTarget(internalVersionOutputDir, internalVersionOutputPkg, boilerplate, customArgs.InternalClientSetPackage))
-		packageList = append(packageList,
+		targetList = append(targetList,
-			factoryPackage(
+			factoryTarget(
 				internalVersionOutputDir, internalVersionOutputPkg,
 				boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(customArgs.PluralExceptions),
 				internalGroupVersions, customArgs.InternalClientSetPackage, typesForGroupVersion))
 		for _, gvs := range internalGroupVersions {
-			packageList = append(packageList,
+			targetList = append(targetList,
-				groupPackage(internalVersionOutputDir, internalVersionOutputPkg, gvs, boilerplate))
+				groupTarget(internalVersionOutputDir, internalVersionOutputPkg, gvs, boilerplate))
 		}
 	}
 
-	return packageList
+	return targetList
 }
 
-func factoryPackage(outputDirBase, outputPkgBase string, boilerplate []byte, groupGoNames, pluralExceptions map[string]string, groupVersions map[string]clientgentypes.GroupVersions, clientSetPackage string,
+func factoryTarget(outputDirBase, outputPkgBase string, boilerplate []byte, groupGoNames, pluralExceptions map[string]string, groupVersions map[string]clientgentypes.GroupVersions, clientSetPackage string,
-	typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Package {
+	typesForGroupVersion map[clientgentypes.GroupVersion][]*types.Type) generator.Target {
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       filepath.Base(outputDirBase),
 		PkgPath:       outputPkgBase,
 		PkgDir:        outputDirBase,
@@ -284,11 +284,11 @@ func factoryPackage(outputDirBase, outputPkgBase string, boilerplate []byte, gro
 	}
 }
 
-func factoryInterfacePackage(outputDirBase, outputPkgBase string, boilerplate []byte, clientSetPackage string) generator.Package {
+func factoryInterfaceTarget(outputDirBase, outputPkgBase string, boilerplate []byte, clientSetPackage string) generator.Target {
 	outputDir := subdirForInternalInterfaces(outputDirBase)
 	outputPkg := subdirForInternalInterfaces(outputPkgBase)
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       filepath.Base(outputDir),
 		PkgPath:       outputPkg,
 		PkgDir:        outputDir,
@@ -308,12 +308,12 @@ func factoryInterfacePackage(outputDirBase, outputPkgBase string, boilerplate []
 	}
 }
 
-func groupPackage(outputDirBase, outputPackageBase string, groupVersions clientgentypes.GroupVersions, boilerplate []byte) generator.Package {
+func groupTarget(outputDirBase, outputPackageBase string, groupVersions clientgentypes.GroupVersions, boilerplate []byte) generator.Target {
 	outputDir := filepath.Join(outputDirBase, groupVersions.PackageName)
 	outputPkg := filepath.Join(outputPackageBase, groupVersions.PackageName)
 	groupPkgName := strings.Split(string(groupVersions.PackageName), ".")[0]
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       groupPkgName,
 		PkgPath:       outputPkg,
 		PkgDir:        outputDir,
@@ -337,12 +337,12 @@ func groupPackage(outputDirBase, outputPackageBase string, groupVersions clientg
 	}
 }
 
-func versionPackage(outputDirBase, outputPkgBase string, groupPkgName string, gv clientgentypes.GroupVersion, groupGoName string, boilerplate []byte, typesToGenerate []*types.Type, clientSetPackage, listersPackage string) generator.Package {
+func versionTarget(outputDirBase, outputPkgBase string, groupPkgName string, gv clientgentypes.GroupVersion, groupGoName string, boilerplate []byte, typesToGenerate []*types.Type, clientSetPackage, listersPackage string) generator.Target {
 	subdir := filepath.Join(groupPkgName, strings.ToLower(gv.Version.NonEmpty()))
 	outputDir := filepath.Join(outputDirBase, subdir)
 	outputPkg := filepath.Join(outputPkgBase, subdir)
 
-	return &generator.SimplePackage{
+	return &generator.SimpleTarget{
 		PkgName:       strings.ToLower(gv.Version.NonEmpty()),
 		PkgPath:       outputPkg,
 		PkgDir:        outputDir,

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

@@ -45,7 +45,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -58,8 +58,8 @@ func DefaultNameSystem() string {
 	return "public"
 }
 
-// Packages makes the client package definition.
+// GetTargets makes the client target definition.
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
@@ -67,7 +67,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 
 	customArgs := arguments.CustomArgs.(*listergenargs.CustomArgs)
 
-	var packageList []generator.Package
+	var targetList []generator.Target
 	for _, inputDir := range arguments.InputDirs {
 		p := context.Universe.Package(inputDir)
 
@@ -123,7 +123,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		subdir := filepath.Join(groupPackageName, strings.ToLower(gv.Version.NonEmpty()))
 		outputDir := filepath.Join(arguments.OutputBase, subdir)
 		outputPkg := filepath.Join(customArgs.OutputPackage, subdir)
-		packageList = append(packageList, &generator.SimplePackage{
+		targetList = append(targetList, &generator.SimpleTarget{
 			PkgName:       strings.ToLower(gv.Version.NonEmpty()),
 			PkgPath:       outputPkg,
 			PkgDir:        outputDir,
@@ -159,7 +159,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		})
 	}
 
-	return packageList
+	return targetList
 }
 
 // objectMetaForPackage returns the type of ObjectMeta used by package p.

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

@@ -45,7 +45,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -50,7 +50,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		log.Fatalf("OpenAPI code generation error: %v", err)
 	}

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

@@ -61,7 +61,7 @@ func main() {
 	if err := genericArgs.Execute(
 		statusgenerators.NameSystems(),
 		statusgenerators.DefaultNameSystem(),
-		statusgenerators.Packages,
+		statusgenerators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}

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

@@ -179,14 +179,14 @@ func DefaultNameSystem() string {
 	return "public"
 }
 
-// Packages makes the package definition.
+// GetTargets makes the target definition.
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
-	packages := []generator.Package{}
+	targets := []generator.Target{}
 	header := append([]byte(fmt.Sprintf("// +build !%s\n\n", arguments.GeneratedBuildTag)), boilerplate...)
 
 	for _, i := range context.Inputs {
@@ -230,8 +230,8 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 		}
 
 		if pkgNeedsGeneration {
-			packages = append(packages,
+			targets = append(targets,
-				&generator.SimplePackage{
+				&generator.SimpleTarget{
 					PkgName:       strings.Split(filepath.Base(pkg.Path), ".")[0],
 					PkgPath:       pkg.Path,
 					PkgDir:        pkg.SourcePath, // output pkg is the same as the input
@@ -247,7 +247,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 				})
 		}
 	}
-	return packages
+	return targets
 }
 
 // genDeepCopy produces a file with autogenerated deep-copy functions.

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

@@ -42,14 +42,14 @@ func DefaultNameSystem() string {
 	return "public"
 }
 
-// Packages makes packages to generate.
+// GetTargets makes targets to generate.
-func Packages(context *generator.Context, arguments *args.GeneratorArgs) []generator.Package {
+func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
 	boilerplate, err := arguments.LoadGoBoilerplate()
 	if err != nil {
 		klog.Fatalf("Failed loading boilerplate: %v", err)
 	}
 
-	packages := []generator.Package{}
+	targets := []generator.Target{}
 	for _, input := range context.Inputs {
 		pkg := context.Universe.Package(input)
 		internal, err := isInternal(pkg)
@@ -99,8 +99,8 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 			}
 		}
 
-		packages = append(packages,
+		targets = append(targets,
-			&generator.SimplePackage{
+			&generator.SimpleTarget{
 				PkgName:       pkg.Name,
 				PkgPath:       pkg.Path,       // output to same pkg as input
 				PkgDir:        pkg.SourcePath, // output to same pkg as input
@@ -121,7 +121,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) []gener
 			})
 	}
 
-	return packages
+	return targets
 }
 
 // isInternal determines whether the given package

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

@@ -41,7 +41,7 @@ func main() {
 	if err := genericArgs.Execute(
 		generators.NameSystems(),
 		generators.DefaultNameSystem(),
-		generators.Packages,
+		generators.GetTargets,
 	); err != nil {
 		klog.Fatalf("Error: %v", err)
 	}