feat(analysis/maxlength): extend linter to support all limits from validation-gen

Author: itzPranshul

pkg/analysis/maxlength/analyzer.go

@@ -16,40 +16,51 @@ limitations under the License.
 package maxlength
 
 import (
-"fmt"
-"go/ast"
-
-"golang.org/x/tools/go/analysis"
-kalerrors "sigs.k8s.io/kube-api-linter/pkg/analysis/errors"
-"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/extractjsontags"
-"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/inspector"
-markershelper "sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/markers"
-"sigs.k8s.io/kube-api-linter/pkg/analysis/utils"
-"sigs.k8s.io/kube-api-linter/pkg/markers"
+	"fmt"
+	"go/ast"
+
+	"golang.org/x/tools/go/analysis"
+	kalerrors "sigs.k8s.io/kube-api-linter/pkg/analysis/errors"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/extractjsontags"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/inspector"
+	markershelper "sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/markers"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/utils"
+	"sigs.k8s.io/kube-api-linter/pkg/markers"
 )
 
 func init() {
 	markershelper.DefaultRegistry().Register(
-markers.KubebuilderMaxLengthMarker,
-markers.KubebuilderMaxItemsMarker,
-markers.KubebuilderItemsMaxLengthMarker,
-markers.KubebuilderEnumMarker,
-markers.KubebuilderItemsEnumMarker,
-markers.KubebuilderFormatMarker,
-markers.KubebuilderItemsFormatMarker,
-markers.K8sMaxLengthMarker,
-markers.K8sMaxItemsMarker,
-markers.K8sEnumMarker,
-)
+		markers.KubebuilderMaxLengthMarker,
+		markers.KubebuilderMaxItemsMarker,
+		markers.KubebuilderItemsMaxLengthMarker,
+		markers.KubebuilderEnumMarker,
+		markers.KubebuilderItemsEnumMarker,
+		markers.KubebuilderFormatMarker,
+		markers.KubebuilderItemsFormatMarker,
+		markers.KubebuilderMaxPropertiesMarker,
+		markers.KubebuilderMaximumMarker,
+		markers.K8sMaxLengthMarker,
+		markers.K8sMaxItemsMarker,
+		markers.K8sEnumMarker,
+		markers.K8sMinLengthMarker,
+		markers.K8sMinItemsMarker,
+		markers.K8sMinimumMarker,
+		markers.K8sMaxPropertiesMarker,
+		markers.K8sMinPropertiesMarker,
+		markers.K8sMaximumMarker,
+		markers.K8sMaxBytesMarker,
+	)
 }
 
 const (
-name = "maxlength"
+	name = "maxlength"
 )
 
 type analyzer struct {
-	preferredMaxLengthMarker string
-	preferredMaxItemsMarker  string
+	preferredMaxLengthMarker     string
+	preferredMaxItemsMarker      string
+	preferredMaxPropertiesMarker string
+	preferredMaximumMarker       string
 }
 
 // newAnalyzer creates a new analyzer with the given configuration.
@@ -61,8 +72,10 @@ func newAnalyzer(cfg *MaxLengthConfig) *analysis.Analyzer {
 	defaultConfig(cfg)
 
 	a := &analyzer{
-		preferredMaxLengthMarker: cfg.PreferredMaxLengthMarker,
-		preferredMaxItemsMarker:  cfg.PreferredMaxItemsMarker,
+		preferredMaxLengthMarker:     cfg.PreferredMaxLengthMarker,
+		preferredMaxItemsMarker:      cfg.PreferredMaxItemsMarker,
+		preferredMaxPropertiesMarker: cfg.PreferredMaxPropertiesMarker,
+		preferredMaximumMarker:       cfg.PreferredMaximumMarker,
 	}
 
 	return &analysis.Analyzer{
@@ -73,25 +86,15 @@ func newAnalyzer(cfg *MaxLengthConfig) *analysis.Analyzer {
 	}
 }
 
-func defaultConfig(cfg *MaxLengthConfig) {
-	if cfg.PreferredMaxLengthMarker == "" {
-		cfg.PreferredMaxLengthMarker = markers.KubebuilderMaxLengthMarker
-	}
-
-	if cfg.PreferredMaxItemsMarker == "" {
-		cfg.PreferredMaxItemsMarker = markers.KubebuilderMaxItemsMarker
-	}
-}
-
 func (a *analyzer) run(pass *analysis.Pass) (any, error) {
 	inspect, ok := pass.ResultOf[inspector.Analyzer].(inspector.Inspector)
 	if !ok {
 		return nil, kalerrors.ErrCouldNotGetInspector
 	}
 
 	inspect.InspectFields(func(field *ast.Field, _ extractjsontags.FieldTagInfo, markersAccess markershelper.Markers, qualifiedFieldName string) {
-a.checkField(pass, field, markersAccess, qualifiedFieldName)
-})
+		a.checkField(pass, field, markersAccess, qualifiedFieldName)
+	})
 
 	return nil, nil //nolint:nilnil
 }
@@ -104,7 +107,11 @@ func (a *analyzer) checkField(pass *analysis.Pass, field *ast.Field, markersAcce
 
 func (a *analyzer) checkIdent(pass *analysis.Pass, ident *ast.Ident, node ast.Node, aliases []*ast.TypeSpec, markersAccess markershelper.Markers, prefix, marker string, needsMaxLength func(markershelper.MarkerSet) bool) {
 	if utils.IsBasicType(pass, ident) { // Built-in type
-		a.checkString(pass, ident, node, aliases, markersAccess, prefix, marker, needsMaxLength)
+		if ident.Name == "string" {
+			a.checkString(pass, ident, node, aliases, markersAccess, prefix, marker, needsMaxLength)
+		} else if isNumericType(ident.Name) {
+			a.checkNumeric(pass, ident, node, aliases, markersAccess, prefix)
+		}
 
 		return
 	}
@@ -129,6 +136,14 @@ func (a *analyzer) checkString(pass *analysis.Pass, ident *ast.Ident, node ast.N
 	}
 }
 
+func (a *analyzer) checkNumeric(pass *analysis.Pass, ident *ast.Ident, node ast.Node, aliases []*ast.TypeSpec, markersAccess markershelper.Markers, prefix string) {
+	markerSet := getCombinedMarkers(markersAccess, node, aliases)
+
+	if needsMaximum(markerSet) {
+		pass.Reportf(node.Pos(), "%s must have a maximum value, add %s marker", prefix, a.preferredMaximumMarker)
+	}
+}
+
 func (a *analyzer) checkTypeSpec(pass *analysis.Pass, tSpec *ast.TypeSpec, node ast.Node, aliases []*ast.TypeSpec, markersAccess markershelper.Markers, prefix, marker string, needsMaxLength func(markershelper.MarkerSet) bool) {
 	if tSpec.Name == nil {
 		return
@@ -148,6 +163,8 @@ func (a *analyzer) checkTypeExpr(pass *analysis.Pass, typeExpr ast.Expr, node as
 		a.checkTypeExpr(pass, typ.X, node, aliases, markersAccess, prefix, marker, needsMaxLength)
 	case *ast.ArrayType:
 		a.checkArrayType(pass, typ, node, aliases, markersAccess, prefix)
+	case *ast.MapType:
+		a.checkMapType(pass, typ, node, aliases, markersAccess, prefix)
 	}
 }
 
@@ -177,6 +194,14 @@ func (a *analyzer) checkArrayType(pass *analysis.Pass, arrayType *ast.ArrayType,
 	}
 }
 
+func (a *analyzer) checkMapType(pass *analysis.Pass, mapType *ast.MapType, node ast.Node, aliases []*ast.TypeSpec, markersAccess markershelper.Markers, prefix string) {
+	markerSet := getCombinedMarkers(markersAccess, node, aliases)
+
+	if needsMaxProperties(markerSet) {
+		pass.Reportf(node.Pos(), "%s must have a maximum number of properties, add %s marker", prefix, a.preferredMaxPropertiesMarker)
+	}
+}
+
 func (a *analyzer) checkArrayElementIdent(pass *analysis.Pass, ident *ast.Ident, node ast.Node, aliases []*ast.TypeSpec, markersAccess markershelper.Markers, prefix string) {
 	if ident.Obj == nil { // Built-in type
 		a.checkString(pass, ident, node, aliases, markersAccess, prefix, markers.KubebuilderItemsMaxLengthMarker, needsItemsMaxLength)
@@ -190,68 +215,100 @@ func (a *analyzer) checkArrayElementIdent(pass *analysis.Pass, ident *ast.Ident,
 	}
 
 	// If the array element wasn't directly a string, allow a string alias to be used
-// with either the items style markers or the on alias style markers.
-a.checkTypeSpec(pass, tSpec, node, append(aliases, tSpec), markersAccess, fmt.Sprintf("%s type", prefix), a.preferredMaxLengthMarker, func(ms markershelper.MarkerSet) bool {
-return needsStringMaxLength(ms) && needsItemsMaxLength(ms)
-})
+	// with either the items style markers or the on alias style markers.
+	a.checkTypeSpec(pass, tSpec, node, append(aliases, tSpec), markersAccess, fmt.Sprintf("%s type", prefix), a.preferredMaxLengthMarker, func(ms markershelper.MarkerSet) bool {
+		return needsStringMaxLength(ms) && needsItemsMaxLength(ms)
+	})
 }
 
 func getCombinedMarkers(markersAccess markershelper.Markers, node ast.Node, aliases []*ast.TypeSpec) markershelper.MarkerSet {
-base := markershelper.NewMarkerSet(getMarkers(markersAccess, node).UnsortedList()...)
+	base := markershelper.NewMarkerSet(getMarkers(markersAccess, node).UnsortedList()...)
 
-for _, a := range aliases {
-base.Insert(getMarkers(markersAccess, a).UnsortedList()...)
-}
+	for _, a := range aliases {
+		base.Insert(getMarkers(markersAccess, a).UnsortedList()...)
+	}
 
-return base
+	return base
 }
 
 func getMarkers(markersAccess markershelper.Markers, node ast.Node) markershelper.MarkerSet {
-switch t := node.(type) {
-case *ast.Field:
-return markersAccess.FieldMarkers(t)
-case *ast.TypeSpec:
-return markersAccess.TypeMarkers(t)
-}
+	switch t := node.(type) {
+	case *ast.Field:
+		return markersAccess.FieldMarkers(t)
+	case *ast.TypeSpec:
+		return markersAccess.TypeMarkers(t)
+	}
 
-return nil
+	return nil
 }
 
-// needsMaxLength returns true if the field needs a maximum length.
+// needsStringMaxLength returns true if the field needs a maximum length.
 // Fields do not need a maximum length if they are already marked with a maximum length,
 // or if they are an enum, or if they are a date, date-time or duration.
 func needsStringMaxLength(markerSet markershelper.MarkerSet) bool {
-switch {
-case markerSet.Has(markers.KubebuilderMaxLengthMarker),
-markerSet.Has(markers.K8sMaxLengthMarker),
-markerSet.Has(markers.KubebuilderEnumMarker),
-markerSet.Has(markers.K8sEnumMarker),
-markerSet.HasWithValue(kubebuilderFormatWithValue("date")),
-markerSet.HasWithValue(kubebuilderFormatWithValue("date-time")),
-markerSet.HasWithValue(kubebuilderFormatWithValue("duration")):
-return false
-}
+	switch {
+	case markerSet.Has(markers.KubebuilderMaxLengthMarker),
+		markerSet.Has(markers.K8sMaxLengthMarker),
+		markerSet.Has(markers.K8sMaxBytesMarker),
+		markerSet.Has(markers.KubebuilderEnumMarker),
+		markerSet.Has(markers.K8sEnumMarker),
+		markerSet.HasWithValue(kubebuilderFormatWithValue("date")),
+		markerSet.HasWithValue(kubebuilderFormatWithValue("date-time")),
+		markerSet.HasWithValue(kubebuilderFormatWithValue("duration")):
+		return false
+	}
 
-return true
+	return true
 }
 
 func needsItemsMaxLength(markerSet markershelper.MarkerSet) bool {
-switch {
-case markerSet.Has(markers.KubebuilderItemsMaxLengthMarker),
-markerSet.Has(markers.KubebuilderItemsEnumMarker),
-markerSet.HasWithValue(kubebuilderItemsFormatWithValue("date")),
-markerSet.HasWithValue(kubebuilderItemsFormatWithValue("date-time")),
-markerSet.HasWithValue(kubebuilderItemsFormatWithValue("duration")):
-return false
+	switch {
+	case markerSet.Has(markers.KubebuilderItemsMaxLengthMarker),
+		markerSet.Has(markers.KubebuilderItemsEnumMarker),
+		markerSet.HasWithValue(kubebuilderItemsFormatWithValue("date")),
+		markerSet.HasWithValue(kubebuilderItemsFormatWithValue("date-time")),
+		markerSet.HasWithValue(kubebuilderItemsFormatWithValue("duration")):
+		return false
+	}
+
+	return true
 }
 
-return true
+func needsMaxProperties(markerSet markershelper.MarkerSet) bool {
+	switch {
+	case markerSet.Has(markers.KubebuilderMaxPropertiesMarker),
+		markerSet.Has(markers.K8sMaxPropertiesMarker):
+		return false
+	}
+
+	return true
+}
+
+func needsMaximum(markerSet markershelper.MarkerSet) bool {
+	switch {
+	case markerSet.Has(markers.KubebuilderMaximumMarker),
+		markerSet.Has(markers.K8sMaximumMarker):
+		return false
+	}
+
+	return true
 }
 
 func kubebuilderFormatWithValue(value string) string {
-return fmt.Sprintf("%s:=%s", markers.KubebuilderFormatMarker, value)
+	return fmt.Sprintf("%s:=%s", markers.KubebuilderFormatMarker, value)
 }
 
 func kubebuilderItemsFormatWithValue(value string) string {
-return fmt.Sprintf("%s:=%s", markers.KubebuilderItemsFormatMarker, value)
+	return fmt.Sprintf("%s:=%s", markers.KubebuilderItemsFormatMarker, value)
+}
+
+func isNumericType(name string) bool {
+	switch name {
+	case "int", "int8", "int16", "int32", "int64",
+		"uint", "uint8", "uint16", "uint32", "uint64",
+		"float32", "float64":
+		return true
+	}
+
+	return false
 }

pkg/analysis/maxlength/config.go

@@ -15,6 +15,8 @@ limitations under the License.
 */
 package maxlength
 
+import "sigs.k8s.io/kube-api-linter/pkg/markers"
+
 // MaxLengthConfig contains configuration for the maxlength linter.
 type MaxLengthConfig struct {
 	// PreferredMaxLengthMarker is the preferred marker identifier to use for maximum length on strings.
@@ -26,4 +28,32 @@ type MaxLengthConfig struct {
 	// If this field is not set, the default value is "kubebuilder:validation:MaxItems".
 	// Valid values are "kubebuilder:validation:MaxItems" and "k8s:maxItems".
 	PreferredMaxItemsMarker string `json:"preferredMaxItemsMarker"`
+
+	// PreferredMaxPropertiesMarker is the preferred marker identifier to use for maximum properties on maps.
+	// If this field is not set, the default value is "kubebuilder:validation:MaxProperties".
+	// Valid values are "kubebuilder:validation:MaxProperties" and "k8s:maxProperties".
+	PreferredMaxPropertiesMarker string `json:"preferredMaxPropertiesMarker"`
+
+	// PreferredMaximumMarker is the preferred marker identifier to use for maximum value on numbers.
+	// If this field is not set, the default value is "kubebuilder:validation:Maximum".
+	// Valid values are "kubebuilder:validation:Maximum" and "k8s:maximum".
+	PreferredMaximumMarker string `json:"preferredMaximumMarker"`
+}
+
+func defaultConfig(cfg *MaxLengthConfig) {
+	if cfg.PreferredMaxLengthMarker == "" {
+		cfg.PreferredMaxLengthMarker = markers.KubebuilderMaxLengthMarker
+	}
+
+	if cfg.PreferredMaxItemsMarker == "" {
+		cfg.PreferredMaxItemsMarker = markers.KubebuilderMaxItemsMarker
+	}
+
+	if cfg.PreferredMaxPropertiesMarker == "" {
+		cfg.PreferredMaxPropertiesMarker = markers.KubebuilderMaxPropertiesMarker
+	}
+
+	if cfg.PreferredMaximumMarker == "" {
+		cfg.PreferredMaximumMarker = markers.KubebuilderMaximumMarker
+	}
 }

pkg/analysis/maxlength/initializer.go

@@ -64,5 +64,17 @@ func validateConfig(config *MaxLengthConfig, fldPath *field.Path) field.ErrorLis
 		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("preferredMaxItemsMarker"), config.PreferredMaxItemsMarker, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", markers.KubebuilderMaxItemsMarker, markers.K8sMaxItemsMarker)))
 	}
 
+	switch config.PreferredMaxPropertiesMarker {
+	case "", markers.KubebuilderMaxPropertiesMarker, markers.K8sMaxPropertiesMarker:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("preferredMaxPropertiesMarker"), config.PreferredMaxPropertiesMarker, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", markers.KubebuilderMaxPropertiesMarker, markers.K8sMaxPropertiesMarker)))
+	}
+
+	switch config.PreferredMaximumMarker {
+	case "", markers.KubebuilderMaximumMarker, markers.K8sMaximumMarker:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("preferredMaximumMarker"), config.PreferredMaximumMarker, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", markers.KubebuilderMaximumMarker, markers.K8sMaximumMarker)))
+	}
+
 	return fieldErrors
 }

pkg/analysis/maxlength/testdata/src/a/limits.go

@@ -0,0 +1,30 @@
+package a
+
+type Limits struct {
+	// +k8s:maxLength=256
+	StringWithK8sMaxLength string
+
+	// +k8s:maxBytes=512
+	StringWithK8sMaxBytes string
+
+	// +k8s:maxItems=128
+	ArrayWithK8sMaxItems []int
+
+	// +k8s:maxProperties=64
+	MapWithK8sMaxProperties map[string]string
+
+	// +k8s:maximum=100
+	IntWithK8sMaximum int32
+
+	// +kubebuilder:validation:MaxProperties=32
+	MapWithKubebuilderMaxProperties map[string]int
+
+	// +kubebuilder:validation:Maximum=50
+	IntWithKubebuilderMaximum int64
+
+	// Missing limits
+	StringWithoutLimit string // want "field Limits.StringWithoutLimit must have a maximum length, add kubebuilder:validation:MaxLength marker"
+	ArrayWithoutLimit  []int  // want "field Limits.ArrayWithoutLimit must have a maximum items, add kubebuilder:validation:MaxItems marker"
+	MapWithoutLimit    map[string]string // want "field Limits.MapWithoutLimit must have a maximum number of properties, add kubebuilder:validation:MaxProperties marker"
+	IntWithoutLimit    int32 // want "field Limits.IntWithoutLimit must have a maximum value, add kubebuilder:validation:Maximum marker"
+}