Merge branch 'main' into update-importas

Author: dongjiang1989

.github/workflows/golangci-lint.yml

@@ -33,6 +33,6 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@e7fa5ac41e1cf5b7d48e45e42232ce7ada589601 # tag=v9.1.0
         with:
-          version: v2.5.0
+          version: v2.6.0
           args: --output.text.print-linter-name=true --output.text.colors=true --timeout 10m
           working-directory: ${{matrix.working-directory}}

.golangci.yml

@@ -33,6 +33,7 @@ linters:
     - iotamixing
     - makezero
     - misspell
+    - modernize
     - nakedret
     - nilerr
     - nolintlint

pkg/applyconfiguration/testdata/cronjob/api/v1/cronjob_types.go

@@ -26,6 +26,7 @@ import (
 	"encoding"
 	"encoding/json"
 	"fmt"
+	"maps"
 	"net/url"
 	"strconv"
 	"time"
@@ -412,8 +413,8 @@ type ContainsNestedMap struct {
 // +kubebuilder:validation:Type=object
 // +kubebuilder:pruning:PreserveUnknownFields
 type Preserved struct {
-	ConcreteField string                 `json:"concreteField"`
-	Rest          map[string]interface{} `json:"-"`
+	ConcreteField string         `json:"concreteField"`
+	Rest          map[string]any `json:"-"`
 }
 
 func (p *Preserved) UnmarshalJSON(data []byte) error {
@@ -434,10 +435,8 @@ func (p *Preserved) UnmarshalJSON(data []byte) error {
 }
 
 func (p *Preserved) MarshalJSON() ([]byte, error) {
-	full := make(map[string]interface{}, len(p.Rest)+1)
-	for k, v := range p.Rest {
-		full[k] = v
-	}
+	full := make(map[string]any, len(p.Rest)+1)
+	maps.Copy(full, p.Rest)
 	full["concreteField"] = p.ConcreteField
 	return json.Marshal(full)
 }

pkg/crd/flatten.go

@@ -38,7 +38,7 @@ type ErrorRecorder interface {
 
 // isOrNil checks if val is nil if val is of a nillable type, otherwise,
 // it compares val to valInt (which should probably be the zero value).
-func isOrNil(val reflect.Value, valInt interface{}, zeroInt interface{}) bool {
+func isOrNil(val reflect.Value, valInt any, zeroInt any) bool {
 	switch valKind := val.Kind(); valKind {
 	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 		return val.IsNil()

pkg/crd/gen.go

@@ -108,15 +108,15 @@ func (Generator) RegisterMarkers(into *markers.Registry) error {
 }
 
 // transformRemoveCRDStatus ensures we do not write the CRD status field.
-func transformRemoveCRDStatus(obj map[string]interface{}) error {
+func transformRemoveCRDStatus(obj map[string]any) error {
 	delete(obj, "status")
 	return nil
 }
 
 // transformPreserveUnknownFields adds spec.preserveUnknownFields=value.
-func transformPreserveUnknownFields(value bool) func(map[string]interface{}) error {
-	return func(obj map[string]interface{}) error {
-		if spec, ok := obj["spec"].(map[interface{}]interface{}); ok {
+func transformPreserveUnknownFields(value bool) func(map[string]any) error {
+	return func(obj map[string]any) error {
+		if spec, ok := obj["spec"].(map[any]any); ok {
 			spec["preserveUnknownFields"] = value
 		}
 		return nil
@@ -185,7 +185,7 @@ func (g Generator) Generate(ctx *genall.GenerationContext) error {
 		// Prevent the top level metadata for the CRD to be generate regardless of the intention in the arguments
 		FixTopLevelMetadata(crdRaw)
 
-		versionedCRDs := make([]interface{}, len(crdVersions))
+		versionedCRDs := make([]any, len(crdVersions))
 		for i, ver := range crdVersions {
 			conv, err := AsVersion(crdRaw, schema.GroupVersion{Group: apiextensionsv1.SchemeGroupVersion.Group, Version: ver})
 			if err != nil {
@@ -202,7 +202,7 @@ func (g Generator) Generate(ctx *genall.GenerationContext) error {
 			} else {
 				fileName = fmt.Sprintf("%s_%s.%s.yaml", crdRaw.Spec.Group, crdRaw.Spec.Names.Plural, crdVersions[i])
 			}
-			if err := ctx.WriteYAML(fileName, headerText, []interface{}{crd}, yamlOpts...); err != nil {
+			if err := ctx.WriteYAML(fileName, headerText, []any{crd}, yamlOpts...); err != nil {
 				return err
 			}
 		}

pkg/crd/known_types.go

@@ -17,6 +17,8 @@ limitations under the License.
 package crd
 
 import (
+	"maps"
+
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-tools/pkg/loader"
@@ -156,13 +158,9 @@ func AddKnownTypes(parser *Parser) {
 	// ensure everything is there before adding to PackageOverrides
 	// TODO(directxman12): this is a bit of a hack, maybe just use constructors?
 	parser.init()
-	for pkgName, override := range KnownPackages {
-		parser.PackageOverrides[pkgName] = override
-	}
+	maps.Copy(parser.PackageOverrides, KnownPackages)
 	// if we want to generate the embedded ObjectMeta in the CRD we need to add the ObjectMetaPackages
 	if parser.GenerateEmbeddedObjectMeta {
-		for pkgName, override := range ObjectMetaPackages {
-			parser.PackageOverrides[pkgName] = override
-		}
+		maps.Copy(parser.PackageOverrides, ObjectMetaPackages)
 	}
 }

pkg/crd/markers/register.go

@@ -79,7 +79,7 @@ type hasHelp interface {
 
 // mustMakeAllWithPrefix converts each object into a marker definition using
 // the object's type's with the prefix to form the marker name.
-func mustMakeAllWithPrefix(prefix string, target markers.TargetType, objs ...interface{}) []*definitionWithHelp {
+func mustMakeAllWithPrefix(prefix string, target markers.TargetType, objs ...any) []*definitionWithHelp {
 	defs := make([]*definitionWithHelp, len(objs))
 	for i, obj := range objs {
 		name := prefix + reflect.TypeOf(obj).Name()

pkg/crd/markers/validation.go

@@ -233,7 +233,7 @@ type MinProperties int
 
 // Enum specifies that this (scalar) field is restricted to the *exact* values specified here.
 // +controllertools:marker:generateHelp:category="CRD validation"
-type Enum []interface{}
+type Enum []any
 
 // Format specifies additional "complex" formatting for this field.
 //
@@ -265,7 +265,7 @@ type Nullable struct{}
 // submission of the containing CRD to an apiserver.
 // +controllertools:marker:generateHelp:category="CRD validation"
 type Default struct {
-	Value interface{}
+	Value any
 }
 
 // Title sets the title for this field.
@@ -276,7 +276,7 @@ type Default struct {
 // important context about what the schema represents.
 // +controllertools:marker:generateHelp:category="CRD validation"
 type Title struct {
-	Value interface{}
+	Value any
 }
 
 // KubernetesDefault sets the default value for this field.
@@ -290,7 +290,7 @@ type Title struct {
 // submission of the containing CRD to an apiserver.
 // +controllertools:marker:generateHelp:category="CRD validation"
 type KubernetesDefault struct {
-	Value interface{}
+	Value any
 }
 
 // Example sets the example value for this field.
@@ -303,7 +303,7 @@ type KubernetesDefault struct {
 // submission of the containing CRD to an apiserver.
 // +controllertools:marker:generateHelp:category="CRD validation"
 type Example struct {
-	Value interface{}
+	Value any
 }
 
 // XPreserveUnknownFields stops the apiserver from pruning fields which are not specified.

pkg/crd/parser.go

@@ -172,12 +172,7 @@ func (p *Parser) NeedSchemaFor(typ TypeIdent) {
 	// avoid tripping recursive schemata, like ManagedFields, by adding an empty WIP schema
 	p.Schemata[typ] = apiextensionsv1.JSONSchemaProps{}
 
-	schemaCtx := newSchemaContext(typ.Package, p, func(typ TypeIdent) *apiextensionsv1.JSONSchemaProps {
-		p.NeedSchemaFor(typ)
-
-		props := p.Schemata[typ]
-		return &props
-	}, p.AllowDangerousTypes, p.IgnoreUnexportedFields)
+	schemaCtx := newSchemaContext(typ.Package, p, p.AllowDangerousTypes, p.IgnoreUnexportedFields)
 	ctxForInfo := schemaCtx.ForInfo(info)
 
 	pkgMarkers, err := markers.PackageMarkers(p.Collector, typ.Package)

pkg/crd/schema.go

@@ -57,12 +57,10 @@ type applyFirstMarker interface {
 	ApplyFirst()
 }
 
-// schemaFetcher is a function that fetches a schema for a given type.
-type schemaFetcher func(TypeIdent) *apiextensionsv1.JSONSchemaProps
-
 // schemaRequester knows how to marker that another schema (e.g. via an external reference) is necessary.
 type schemaRequester interface {
 	NeedSchemaFor(typ TypeIdent)
+	LookupType(pkg *loader.Package, name string) *markers.TypeInfo
 }
 
 // schemaContext stores and provides information across a hierarchy of schema generation.
@@ -71,7 +69,6 @@ type schemaContext struct {
 	info *markers.TypeInfo
 
 	schemaRequester schemaRequester
-	schemaFetcher   schemaFetcher
 	PackageMarkers  markers.MarkerValues
 
 	allowDangerousTypes    bool
@@ -80,12 +77,11 @@ type schemaContext struct {
 
 // newSchemaContext constructs a new schemaContext for the given package and schema requester.
 // It must have type info added before use via ForInfo.
-func newSchemaContext(pkg *loader.Package, req schemaRequester, fetcher schemaFetcher, allowDangerousTypes, ignoreUnexportedFields bool) *schemaContext {
+func newSchemaContext(pkg *loader.Package, req schemaRequester, allowDangerousTypes, ignoreUnexportedFields bool) *schemaContext {
 	pkg.NeedTypesInfo()
 	return &schemaContext{
 		pkg:                    pkg,
 		schemaRequester:        req,
-		schemaFetcher:          fetcher,
 		allowDangerousTypes:    allowDangerousTypes,
 		ignoreUnexportedFields: ignoreUnexportedFields,
 	}
@@ -98,7 +94,6 @@ func (c *schemaContext) ForInfo(info *markers.TypeInfo) *schemaContext {
 		pkg:                    c.pkg,
 		info:                   info,
 		schemaRequester:        c.schemaRequester,
-		schemaFetcher:          c.schemaFetcher,
 		allowDangerousTypes:    c.allowDangerousTypes,
 		ignoreUnexportedFields: c.ignoreUnexportedFields,
 	}
@@ -231,7 +226,7 @@ func typeToSchema(ctx *schemaContext, rawType ast.Expr) *apiextensionsv1.JSONSch
 	case *ast.MapType:
 		props = mapToSchema(ctx, expr)
 	case *ast.StarExpr:
-		props = typeToSchema(ctx, expr.X)
+		props = typeToSchema(ctx.ForInfo(&markers.TypeInfo{}), expr.X)
 	case *ast.StructType:
 		props = structToSchema(ctx, expr)
 	default:
@@ -240,9 +235,7 @@ func typeToSchema(ctx *schemaContext, rawType ast.Expr) *apiextensionsv1.JSONSch
 		return &apiextensionsv1.JSONSchemaProps{}
 	}
 
-	if ctx.info.Doc != "" {
-		props.Description = ctx.info.Doc
-	}
+	props.Description = ctx.info.Doc
 
 	applyMarkers(ctx, ctx.info.Markers, props, rawType)
 
@@ -278,7 +271,6 @@ func localNamedToSchema(ctx *schemaContext, ident *ast.Ident) *apiextensionsv1.J
 	if aliasInfo, isAlias := typeInfo.(*types.Alias); isAlias {
 		typeInfo = aliasInfo.Rhs()
 	}
-
 	if basicInfo, isBasic := typeInfo.(*types.Basic); isBasic {
 		typ, fmt, err := builtinToType(basicInfo, ctx.allowDangerousTypes)
 		if err != nil {
@@ -290,21 +282,50 @@ func localNamedToSchema(ctx *schemaContext, ident *ast.Ident) *apiextensionsv1.J
 		// > Otherwise, the alias information is only in the type name, which
 		// > points directly to the actual (aliased) type.
 		if basicInfo.Name() != ident.Name {
-			return ctx.schemaFetcher(TypeIdent{
-				Package: ctx.pkg,
-				Name:    ident.Name,
-			})
+			ctx.requestSchema("", ident.Name)
+			link := TypeRefLink("", ident.Name)
+			return &apiext.JSONSchemaProps{
+				Type:   typ,
+				Format: fmt,
+				Ref:    &link,
+			}
 		}
 		return &apiextensionsv1.JSONSchemaProps{
 			Type:   typ,
 			Format: fmt,
 		}
 	}
+	// NB(directxman12): if there are dot imports, this might be an external reference,
+	// so use typechecking info to get the actual object
+	typeNameInfo := typeInfo.(interface{ Obj() *types.TypeName }).Obj()
+	pkg := typeNameInfo.Pkg()
+	pkgPath := loader.NonVendorPath(pkg.Path())
+	if pkg == ctx.pkg.Types {
+		pkgPath = ""
+	}
+	ctx.requestSchema(pkgPath, typeNameInfo.Name())
+	link := TypeRefLink(pkgPath, typeNameInfo.Name())
+
+	// In cases where we have a named type, apply the type and format from the named schema
+	// to allow markers that need this information to apply correctly.
+	var typ, fmt string
+	if namedInfo, isNamed := typeInfo.(*types.Named); isNamed {
+		// We don't want/need to do this for structs, maps, or arrays.
+		// These are already handled in infoToSchema if they have custom marshalling.
+		if _, isBasic := namedInfo.Underlying().(*types.Basic); isBasic {
+			namedTypeInfo := ctx.schemaRequester.LookupType(ctx.pkg, namedInfo.Obj().Name())
+
+			namedSchema := infoToSchema(ctx.ForInfo(namedTypeInfo))
+			typ = namedSchema.Type
+			fmt = namedSchema.Format
+		}
+	}
 
-	return ctx.schemaFetcher(TypeIdent{
-		Package: ctx.pkg,
-		Name:    ident.Name,
-	})
+	return &apiext.JSONSchemaProps{
+		Type:   typ,
+		Format: fmt,
+		Ref:    &link,
+	}
 }
 
 // namedSchema creates a schema (ref) for an explicitly external type reference.
@@ -504,9 +525,7 @@ func structToSchema(ctx *schemaContext, structType *ast.StructType) *apiextensio
 		} else {
 			propSchema = typeToSchema(ctx.ForInfo(&markers.TypeInfo{}), field.RawField.Type)
 		}
-		if field.Doc != "" {
-			propSchema.Description = field.Doc
-		}
+		propSchema.Description = field.Doc
 
 		applyMarkers(ctx, field.Markers, propSchema, field.RawField)