Rename DefaultPackage to SimplePackage

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

@@ -161,16 +161,16 @@ 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.DefaultPackage {
+func generatorForApplyConfigurationsPackage(outputDirBase, outputPkgBase, pkgSubdir string, boilerplate []byte, gv clientgentypes.GroupVersion, typesToGenerate []applyConfig, refs refGraph, models *typeModels) generator.Package {
 	outputDir := filepath.Join(outputDirBase, pkgSubdir)
 	outputPkg := filepath.Join(outputPkgBase, pkgSubdir)
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: gv.Version.PackageName(),
+		PkgName:       gv.Version.PackageName(),
-		PackagePath: outputPkg,
+		PkgPath:       outputPkg,
-		Source:      outputDir,
+		PkgDir:        outputDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			for _, toGenerate := range typesToGenerate {
 				var openAPIType *string
 				gvk := gvk{
@@ -199,13 +199,13 @@ 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.DefaultPackage {
+func generatorForUtils(outputDirBase, outputPkgBase string, boilerplate []byte, groupVersions map[string]clientgentypes.GroupVersions, applyConfigsForGroupVersion map[clientgentypes.GroupVersion][]applyConfig, groupGoNames map[string]string) generator.Package {
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: filepath.Base(outputPkgBase),
+		PkgName:       filepath.Base(outputPkgBase),
-		PackagePath: outputPkgBase,
+		PkgPath:       outputPkgBase,
-		Source:      outputDirBase,
+		PkgDir:        outputDirBase,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = append(generators, &utilGenerator{
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "utils",
@@ -221,15 +221,15 @@ func generatorForUtils(outputDirBase, outputPkgBase string, boilerplate []byte,
 	}
 }
 
-func generatorForInternal(outputDirBase, outputPkgBase string, boilerplate []byte, models *typeModels) *generator.DefaultPackage {
+func generatorForInternal(outputDirBase, outputPkgBase string, boilerplate []byte, models *typeModels) generator.Package {
 	outputDir := filepath.Join(outputDirBase, "internal")
 	outputPkg := filepath.Join(outputPkgBase, "internal")
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: filepath.Base(outputPkg),
+		PkgName:       filepath.Base(outputPkg),
-		PackagePath: outputPkg,
+		PkgPath:       outputPkg,
-		Source:      outputDir,
+		PkgDir:        outputDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = append(generators, &internalGenerator{
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "internal",

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

@@ -132,15 +132,15 @@ func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli
 	gvDir := filepath.Join(clientsetDir, subdir)
 	gvPkg := filepath.Join(clientsetPkg, subdir)
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName:          strings.ToLower(gv.Version.NonEmpty()),
+		PkgName:       strings.ToLower(gv.Version.NonEmpty()),
-		PackagePath:          gvPkg,
+		PkgPath:       gvPkg,
-		Source:               gvDir,
+		PkgDir:        gvDir,
-		HeaderText:           boilerplate,
+		HeaderComment: boilerplate,
-		PackageDocumentation: []byte("// This package has the automatically generated typed clients.\n"),
+		PkgDocComment: []byte("// This package has the automatically generated typed clients.\n"),
-		// GeneratorFunc returns a list of generators. Each generator makes a
+		// GeneratorsFunc returns a list of generators. Each generator makes a
 		// single file.
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = []generator.Generator{
 				// Always generate a "doc.go" file.
 				generator.DefaultGen{OptionalName: "doc"},
@@ -197,14 +197,14 @@ 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 {
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: customArgs.ClientsetName,
+		PkgName:       customArgs.ClientsetName,
-		PackagePath: clientsetPkg,
+		PkgPath:       clientsetPkg,
-		Source:      clientsetDir,
+		PkgDir:        clientsetDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		// GeneratorFunc returns a list of generators. Each generator generates a
+		// GeneratorsFunc returns a list of generators. Each generator generates a
 		// single file.
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = []generator.Generator{
 				&genClientset{
 					DefaultGen: generator.DefaultGen{
@@ -237,15 +237,15 @@ NextGroup:
 		}
 	}
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName:          "scheme",
+		PkgName:       "scheme",
-		PackagePath:          schemePkg,
+		PkgPath:       schemePkg,
-		Source:               schemeDir,
+		PkgDir:        schemeDir,
-		HeaderText:           boilerplate,
+		HeaderComment: boilerplate,
-		PackageDocumentation: []byte("// This package contains the scheme of the automatically generated clientset.\n"),
+		PkgDocComment: []byte("// This package contains the scheme of the automatically generated clientset.\n"),
-		// GeneratorFunc returns a list of generators. Each generator generates a
+		// GeneratorsFunc returns a list of generators. Each generator generates a
 		// single file.
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = []generator.Generator{
 				// Always generate a "doc.go" file.
 				generator.DefaultGen{OptionalName: "doc"},

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

@@ -36,17 +36,15 @@ func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli
 	outputPkg := filepath.Join(clientsetPkg, subdir, "fake")
 	realClientPkg := filepath.Join(clientsetPkg, subdir)
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: "fake",
+		PkgName:       "fake",
-		PackagePath: outputPkg,
+		PkgPath:       outputPkg,
-		Source:      outputDir,
+		PkgDir:        outputDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		PackageDocumentation: []byte(
+		PkgDocComment: []byte("// Package fake has the automatically generated clients.\n"),
-			`// Package fake has the automatically generated clients.
+		// GeneratorsFunc returns a list of generators. Each generator makes a
-`),
-		// GeneratorFunc returns a list of generators. Each generator makes a
 		// single file.
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = []generator.Generator{
 				// Always generate a "doc.go" file.
 				generator.DefaultGen{OptionalName: "doc"},
@@ -90,19 +88,17 @@ 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 {
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
 		// TODO: we'll generate fake clientset for different release in the future.
 		// Package name and path are hard coded for now.
-		PackageName: "fake",
+		PkgName:       "fake",
-		PackagePath: filepath.Join(clientsetPkg, "fake"),
+		PkgPath:       filepath.Join(clientsetPkg, "fake"),
-		Source:      filepath.Join(clientsetDir, "fake"),
+		PkgDir:        filepath.Join(clientsetDir, "fake"),
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		PackageDocumentation: []byte(
+		PkgDocComment: []byte("// This package has the automatically generated fake clientset.\n"),
-			`// This package has the automatically generated fake clientset.
+		// GeneratorsFunc returns a list of generators. Each generator generates a
-`),
-		// GeneratorFunc returns a list of generators. Each generator generates a
 		// single file.
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = []generator.Generator{
 				// Always generate a "doc.go" file.
 				generator.DefaultGen{OptionalName: "doc"},

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

@@ -331,19 +331,19 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 		}
 
 		packages = append(packages,
-			&generator.DefaultPackage{
+			&generator.SimplePackage{
-				PackageName: filepath.Base(pkg.Path),
+				PkgName:       filepath.Base(pkg.Path),
-				PackagePath: pkg.Path,
+				PkgPath:       pkg.Path,
-				Source:      pkg.SourcePath, // output pkg is the same as the input
+				PkgDir:        pkg.SourcePath, // output pkg is the same as the input
-				HeaderText:  header,
+				HeaderComment: header,
-				GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+				FilterFunc: func(c *generator.Context, t *types.Type) bool {
+					return t.Name.Package == typesPkg.Path
+				},
+				GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 					return []generator.Generator{
 						NewGenConversion(arguments.OutputFileBaseName, typesPkg.Path, pkg.Path, manualConversions, pkgToPeers[pkg.Path], unsafeEquality),
 					}
 				},
-				FilterFunc: func(c *generator.Context, t *types.Type) bool {
-					return t.Name.Package == typesPkg.Path
-				},
 			})
 	}
 

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

@@ -195,8 +195,8 @@ func Run(g *Generator) {
 		pkg := c.Universe[input]
 		protopkg := newProtobufPackage(pkg.Path, pkg.SourcePath, mod.name, mod.allTypes, omitTypes)
 		header := append([]byte{}, boilerplate...)
-		header = append(header, protopkg.HeaderText...)
+		header = append(header, protopkg.HeaderComment...)
-		protopkg.HeaderText = header
+		protopkg.HeaderComment = header
 		protobufNames.Add(protopkg)
 		if mod.output {
 			outputPackages = append(outputPackages, protopkg)
@@ -291,7 +291,7 @@ func Run(g *Generator) {
 		if err != nil {
 			log.Println(strings.Join(cmd.Args, " "))
 			log.Println(string(out))
-			log.Fatalf("Unable to run protoc on %s: %v", p.PackageName, err)
+			log.Fatalf("Unable to run protoc on %s: %v", p.Name(), err)
 		}
 
 		if g.SkipGeneratedRewrite {
@@ -312,7 +312,7 @@ func Run(g *Generator) {
 		}
 		if err != nil {
 			log.Println(strings.Join(cmd.Args, " "))
-			log.Fatalf("Unable to rewrite imports for %s: %v", p.PackageName, err)
+			log.Fatalf("Unable to rewrite imports for %s: %v", p.Name(), err)
 		}
 
 		// format and simplify the generated file
@@ -323,7 +323,7 @@ func Run(g *Generator) {
 		}
 		if err != nil {
 			log.Println(strings.Join(cmd.Args, " "))
-			log.Fatalf("Unable to apply gofmt for %s: %v", p.PackageName, err)
+			log.Fatalf("Unable to apply gofmt for %s: %v", p.Name(), err)
 		}
 	}
 
@@ -349,7 +349,7 @@ func Run(g *Generator) {
 			continue
 		}
 
-		pattern := filepath.Join(g.OutputBase, p.PackagePath, "*.go")
+		pattern := filepath.Join(g.OutputBase, p.Path(), "*.go")
 		files, err := filepath.Glob(pattern)
 		if err != nil {
 			log.Fatalf("Can't glob pattern %q: %v", pattern, err)
@@ -369,13 +369,13 @@ func Run(g *Generator) {
 func deps(c *generator.Context, pkgs []*protobufPackage) map[string][]string {
 	ret := map[string][]string{}
 	for _, p := range pkgs {
-		pkg, ok := c.Universe[p.PackagePath]
+		pkg, ok := c.Universe[p.Path()]
 		if !ok {
-			log.Fatalf("Unrecognized package: %s", p.PackagePath)
+			log.Fatalf("Unrecognized package: %s", p.Path())
 		}
 
 		for _, d := range pkg.Imports {
-			ret[p.PackagePath] = append(ret[p.PackagePath], d.Path)
+			ret[p.Path()] = append(ret[p.Path()], d.Path)
 		}
 	}
 	return ret
@@ -460,7 +460,7 @@ func (o positionOrder) Len() int {
 }
 
 func (o positionOrder) Less(i, j int) bool {
-	return o.pos[o.elements[i].PackagePath] < o.pos[o.elements[j].PackagePath]
+	return o.pos[o.elements[i].Path()] < o.pos[o.elements[j].Path()]
 }
 
 func (o positionOrder) Swap(i, j int) {

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

@@ -60,8 +60,8 @@ func (n *protobufNamer) Name(t *types.Type) string {
 }
 
 func (n *protobufNamer) Add(p *protobufPackage) {
-	if _, ok := n.packagesByPath[p.PackagePath]; !ok {
+	if _, ok := n.packagesByPath[p.Path()]; !ok {
-		n.packagesByPath[p.PackagePath] = p
+		n.packagesByPath[p.Path()] = p
 		n.packages = append(n.packages, p)
 	}
 }
@@ -70,7 +70,7 @@ func (n *protobufNamer) GoNameToProtoName(name types.Name) types.Name {
 	if p, ok := n.packagesByPath[name.Package]; ok {
 		return types.Name{
 			Name:    name.Name,
-			Package: p.PackageName,
+			Package: p.Name(),
 			Path:    p.ImportPath(),
 		}
 	}
@@ -78,7 +78,7 @@ func (n *protobufNamer) GoNameToProtoName(name types.Name) types.Name {
 		if _, ok := p.FilterTypes[name]; ok {
 			return types.Name{
 				Name:    name.Name,
-				Package: p.PackageName,
+				Package: p.Name(),
 				Path:    p.ImportPath(),
 			}
 		}
@@ -109,7 +109,7 @@ func assignGoTypeToProtoPackage(p *protobufPackage, t *types.Type, local, global
 		}
 		return
 	}
-	if t.Name.Package == p.PackagePath {
+	if t.Name.Package == p.Path() {
 		// Associate types only to their own package
 		global[t.Name] = p
 	}
@@ -175,7 +175,7 @@ func (n *protobufNamer) AssignTypesToPackages(c *generator.Context) error {
 		optional := make(map[types.Name]struct{})
 		p.Imports = NewImportTracker(p.ProtoTypeName())
 		for _, t := range c.Order {
-			if t.Name.Package != p.PackagePath {
+			if t.Name.Package != p.Path() {
 				continue
 			}
 			if !isTypeApplicableToProtobuf(t) {

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

@@ -31,31 +31,25 @@ import (
 
 func newProtobufPackage(packagePath, packageDir, packageName string, generateAll bool, omitFieldTypes map[types.Name]struct{}) *protobufPackage {
 	pkg := &protobufPackage{
-		DefaultPackage: generator.DefaultPackage{
+		SimplePackage: generator.SimplePackage{
 			// The protobuf package name (foo.bar.baz)
-			PackageName: packageName,
+			PkgName:       packageName,
-			PackagePath: packagePath,
+			PkgPath:       packagePath,
-			Source:      packageDir,
+			PkgDir:        packageDir,
-			HeaderText: []byte(
+			HeaderComment: []byte("\n// This file was autogenerated by go-to-protobuf. Do not edit it manually!\n\n"),
-				`
+			PkgDocComment: []byte(fmt.Sprintf("// Package %s is an autogenerated protobuf IDL.\n", packageName)),
-// This file was autogenerated by go-to-protobuf. Do not edit it manually!
-
-`),
-			PackageDocumentation: []byte(fmt.Sprintf(
-				`// Package %s is an autogenerated protobuf IDL.
-`, packageName)),
 		},
 		GenerateAll:    generateAll,
 		OmitFieldTypes: omitFieldTypes,
 	}
 	pkg.FilterFunc = pkg.filterFunc
-	pkg.GeneratorFunc = pkg.generatorFunc
+	pkg.GeneratorsFunc = pkg.generatorsFunc
 	return pkg
 }
 
 // protobufPackage contains the protobuf implementation of Package.
 type protobufPackage struct {
-	generator.DefaultPackage
+	generator.SimplePackage
 
 	// If true, generate protobuf serializations for all public types.
 	// If false, only generate protobuf serializations for structs that
@@ -87,7 +81,7 @@ type protobufPackage struct {
 
 func (p *protobufPackage) Clean() error {
 	for _, s := range []string{p.ImportPath(), p.OutputPath()} {
-		if err := os.Remove(filepath.Join(p.Source, filepath.Base(s))); err != nil && !os.IsNotExist(err) {
+		if err := os.Remove(filepath.Join(p.SourcePath(), filepath.Base(s))); err != nil && !os.IsNotExist(err) {
 			return err
 		}
 	}
@@ -175,7 +169,7 @@ func (p *protobufPackage) ExtractGeneratedType(t *ast.TypeSpec) bool {
 	return true
 }
 
-func (p *protobufPackage) generatorFunc(c *generator.Context) []generator.Generator {
+func (p *protobufPackage) generatorsFunc(c *generator.Context) []generator.Generator {
 	generators := []generator.Generator{}
 
 	p.Imports.AddNullable()
@@ -184,8 +178,8 @@ func (p *protobufPackage) generatorFunc(c *generator.Context) []generator.Genera
 		DefaultGen: generator.DefaultGen{
 			OptionalName: "generated",
 		},
-		localPackage:   types.Name{Package: p.PackageName, Path: p.PackagePath},
+		localPackage:   types.Name{Package: p.Name(), Path: p.Path()},
-		localGoPackage: types.Name{Package: p.PackagePath, Name: p.GoPackageName()},
+		localGoPackage: types.Name{Package: p.Path(), Name: p.GoPackageName()},
 		imports:        p.Imports,
 		generateAll:    p.GenerateAll,
 		omitGogo:       p.OmitGogo,
@@ -195,15 +189,15 @@ func (p *protobufPackage) generatorFunc(c *generator.Context) []generator.Genera
 }
 
 func (p *protobufPackage) GoPackageName() string {
-	return filepath.Base(p.PackagePath)
+	return filepath.Base(p.Path())
 }
 
 func (p *protobufPackage) ImportPath() string {
-	return filepath.Join(p.PackagePath, "generated.proto")
+	return filepath.Join(p.Path(), "generated.proto")
 }
 
 func (p *protobufPackage) OutputPath() string {
-	return filepath.Join(p.PackagePath, "generated.pb.go")
+	return filepath.Join(p.Path(), "generated.pb.go")
 }
 
 var (

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

@@ -249,12 +249,12 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 
 func factoryPackage(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 {
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: filepath.Base(outputDirBase),
+		PkgName:       filepath.Base(outputDirBase),
-		PackagePath: outputPkgBase,
+		PkgPath:       outputPkgBase,
-		Source:      outputDirBase,
+		PkgDir:        outputDirBase,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = append(generators, &factoryGenerator{
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "factory",
@@ -288,12 +288,12 @@ func factoryInterfacePackage(outputDirBase, outputPkgBase string, boilerplate []
 	outputDir := subdirForInternalInterfaces(outputDirBase)
 	outputPkg := subdirForInternalInterfaces(outputPkgBase)
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: filepath.Base(outputDir),
+		PkgName:       filepath.Base(outputDir),
-		PackagePath: outputPkg,
+		PkgPath:       outputPkg,
-		Source:      outputDir,
+		PkgDir:        outputDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = append(generators, &factoryInterfaceGenerator{
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "factory_interfaces",
@@ -313,12 +313,12 @@ func groupPackage(outputDirBase, outputPackageBase string, groupVersions clientg
 	outputPkg := filepath.Join(outputPackageBase, groupVersions.PackageName)
 	groupPkgName := strings.Split(string(groupVersions.PackageName), ".")[0]
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: groupPkgName,
+		PkgName:       groupPkgName,
-		PackagePath: outputPkg,
+		PkgPath:       outputPkg,
-		Source:      outputDir,
+		PkgDir:        outputDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = append(generators, &groupInterfaceGenerator{
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "interface",
@@ -342,12 +342,12 @@ func versionPackage(outputDirBase, outputPkgBase string, groupPkgName string, gv
 	outputDir := filepath.Join(outputDirBase, subdir)
 	outputPkg := filepath.Join(outputPkgBase, subdir)
 
-	return &generator.DefaultPackage{
+	return &generator.SimplePackage{
-		PackageName: strings.ToLower(gv.Version.NonEmpty()),
+		PkgName:       strings.ToLower(gv.Version.NonEmpty()),
-		PackagePath: outputPkg,
+		PkgPath:       outputPkg,
-		Source:      outputDir,
+		PkgDir:        outputDir,
-		HeaderText:  boilerplate,
+		HeaderComment: boilerplate,
-		GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+		GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 			generators = append(generators, &versionInterfaceGenerator{
 				DefaultGen: generator.DefaultGen{
 					OptionalName: "interface",

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

@@ -123,12 +123,16 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 		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.DefaultPackage{
+		packageList = append(packageList, &generator.SimplePackage{
-			PackageName: strings.ToLower(gv.Version.NonEmpty()),
+			PkgName:       strings.ToLower(gv.Version.NonEmpty()),
-			PackagePath: outputPkg,
+			PkgPath:       outputPkg,
-			Source:      outputDir,
+			PkgDir:        outputDir,
-			HeaderText:  boilerplate,
+			HeaderComment: boilerplate,
-			GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+			FilterFunc: func(c *generator.Context, t *types.Type) bool {
+				tags := util.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
+				return tags.GenerateClient && tags.HasVerb("list") && tags.HasVerb("get")
+			},
+			GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 				generators = append(generators, &expansionGenerator{
 					DefaultGen: generator.DefaultGen{
 						OptionalName: "expansion_generated",
@@ -152,10 +156,6 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 				}
 				return generators
 			},
-			FilterFunc: func(c *generator.Context, t *types.Type) bool {
-				tags := util.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
-				return tags.GenerateClient && tags.HasVerb("list") && tags.HasVerb("get")
-			},
 		})
 	}
 

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

@@ -231,19 +231,19 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 
 		if pkgNeedsGeneration {
 			packages = append(packages,
-				&generator.DefaultPackage{
+				&generator.SimplePackage{
-					PackageName: strings.Split(filepath.Base(pkg.Path), ".")[0],
+					PkgName:       strings.Split(filepath.Base(pkg.Path), ".")[0],
-					PackagePath: pkg.Path,
+					PkgPath:       pkg.Path,
-					Source:      pkg.SourcePath, // output pkg is the same as the input
+					PkgDir:        pkg.SourcePath, // output pkg is the same as the input
-					HeaderText:  header,
+					HeaderComment: header,
-					GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+					FilterFunc: func(c *generator.Context, t *types.Type) bool {
+						return t.Name.Package == pkg.Path
+					},
+					GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 						return []generator.Generator{
 							NewPrereleaseLifecycleGen(arguments.OutputFileBaseName, pkg.Path),
 						}
 					},
-					FilterFunc: func(c *generator.Context, t *types.Type) bool {
-						return t.Name.Package == pkg.Path
-					},
 				})
 		}
 	}

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

@@ -100,12 +100,12 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 		}
 
 		packages = append(packages,
-			&generator.DefaultPackage{
+			&generator.SimplePackage{
-				PackageName: pkg.Name,
+				PkgName:       pkg.Name,
-				PackagePath: pkg.Path,       // output to same pkg as input
+				PkgPath:       pkg.Path,       // output to same pkg as input
-				Source:      pkg.SourcePath, // output to same pkg as input
+				PkgDir:        pkg.SourcePath, // output to same pkg as input
-				HeaderText:  boilerplate,
+				HeaderComment: boilerplate,
-				GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
+				GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
 					return []generator.Generator{
 						&registerExternalGenerator{
 							DefaultGen: generator.DefaultGen{