refactor(markerscope): update scope handling to support multiple scopes for markers

Signed-off-by: nayuta-ai <nayuta723@gmail.com>

Author: nayuta723

docs/linters.md

@@ -399,29 +399,28 @@ The linter defines different scope types for markers:
 
 - **FieldScope**: Can only be applied to struct fields (e.g., `optional`, `required`, `nullable`)
 - **TypeScope**: Can only be applied to type definitions (e.g., `kubebuilder:validation:items:ExactlyOneOf`)
-- **AnyScope**: Can be applied to either fields or type definitions (e.g., `kubebuilder:validation:Minimum`, `kubebuilder:validation:Pattern`)
+- **Field and Type**: Markers that can be applied to both fields and type definitions (e.g., `kubebuilder:validation:Minimum`, `kubebuilder:validation:Pattern`)
 
 ### Type Constraints
 
 The linter validates that markers are applied to compatible OpenAPI schema types:
 
-- **Numeric markers** (`Minimum`, `Maximum`, `MultipleOf`): Only for `integer` or `number` types
+- **Numeric markers** (`Minimum`, `Maximum`, `MultipleOf`): Only for `integer` types
 - **String markers** (`Pattern`, `MinLength`, `MaxLength`): Only for `string` types
 - **Array markers** (`MinItems`, `MaxItems`, `UniqueItems`): Only for `array` types
 - **Object markers** (`MinProperties`, `MaxProperties`): Only for `object` types (struct/map)
 - **Array items markers** (`items:Minimum`, `items:Pattern`, etc.): Apply constraints to array element types
 
 OpenAPI schema types map to Go types as follows:
 - `integer`: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64
-- `number`: float32, float64
 - `string`: string
 - `boolean`: bool
 - `array`: []T, [N]T (slices and arrays)
 - `object`: struct, map[K]V
 
 #### Strict Type Constraints
 
-For markers with `AnyScope` and type constraints, the `strictTypeConstraint` flag controls where the marker should be declared when used with named types:
+For markers that can be applied to both fields and types with type constraints, the `strictTypeConstraint` flag controls where the marker should be declared when used with named types:
 
 - When `strictTypeConstraint` is `false` (default): The marker can be declared on either the field or the type definition.
 - When `strictTypeConstraint` is `true`: The marker must be declared on the type definition, not on fields using that type.
@@ -461,13 +460,13 @@ The linter includes built-in rules for all standard kubebuilder markers and k8s
 - `kubebuilder:validation:items:AtMostOneOf`
 - `kubebuilder:validation:items:AtLeastOneOf`
 
-**AnyScope markers with type constraints:**
-- `kubebuilder:validation:Minimum` (integer/number types only)
+**Field and Type markers with type constraints:**
+- `kubebuilder:validation:Minimum` (integer types only)
 - `kubebuilder:validation:Pattern` (string types only)
 - `kubebuilder:validation:MinItems` (array types only)
 - `kubebuilder:validation:MinProperties` (object types only)
 
-**AnyScope markers without type constraints:**
+**Field and Type markers without type constraints:**
 - `kubebuilder:validation:Enum`, `kubebuilder:validation:Format`
 - `kubebuilder:pruning:PreserveUnknownFields`, `kubebuilder:title`
 
@@ -476,50 +475,50 @@ The linter includes built-in rules for all standard kubebuilder markers and k8s
 You can customize marker rules or add support for custom markers.
 
 **Scope values:**
-- `Field`: Marker can only be applied to struct fields
-- `Type`: Marker can only be applied to type definitions
-- `Any`: Marker can be applied to either fields or type definitions
+
+The `scopes` field accepts an array of scope constraints:
+- `[Field]`: Marker can only be applied to struct fields
+- `[Type]`: Marker can only be applied to type definitions
+- `[Field, Type]`: Marker can be applied to both fields and type definitions
 
 **Type constraints:**
 
-The `typeConstraint` field allows you to restrict which Go types a marker can be applied to. This ensures that markers are only used with compatible data types (e.g., numeric markers like `Minimum` are only applied to integer/number types).
+The `typeConstraint` field allows you to restrict which Go types a marker can be applied to. This ensures that markers are only used with compatible data types (e.g., numeric markers like `Minimum` are only applied to integer types).
 
 **Type constraint fields:**
-- `allowedSchemaTypes`: List of allowed OpenAPI schema types (`integer`, `number`, `string`, `boolean`, `array`, `object`)
+- `allowedSchemaTypes`: List of allowed OpenAPI schema types (`integer`, `string`, `boolean`, `array`, `object`)
 - `elementConstraint`: Nested constraint for array element types (only valid when `allowedSchemaTypes` includes `array`)
-- `strictTypeConstraint`: When `true`, markers with `AnyScope` and type constraints applied to fields using named types must be declared on the type definition instead of the field. Defaults to `false`.
+- `strictTypeConstraint`: When `true`, markers that can be applied to both fields and types with type constraints applied to fields using named types must be declared on the type definition instead of the field. Defaults to `false`.
 
 **Configuration example:**
 
 ```yaml
 lintersConfig:
   markerscope:
     policy: Warn | SuggestFix # The policy for marker scope violations. Defaults to `Warn`.
-    allowDangerousTypes: false # Allow dangerous number types (float32, float64). Defaults to `false`.
 
     # Override default rules for built-in markers
     overrideMarkers:
       - identifier: "optional"
-        scope: Field  # or: Type, Any
+        scopes: [Field]  # Can specify [Field], [Type], or [Field, Type]
 
     # Add rules for custom markers
     customMarkers:
       # Custom marker with scope constraint only
       - identifier: "mycompany:validation:CustomMarker"
-        scope: Any
+        scopes: [Field, Type]
 
       # Custom marker with scope and type constraints
       - identifier: "mycompany:validation:NumericLimit"
-        scope: Any
+        scopes: [Field, Type]
         strictTypeConstraint: true # Require declaration on type definition for named types
         typeConstraint:
           allowedSchemaTypes:
             - integer
-            - number
 
       # Custom array items marker with element type constraint
       - identifier: "mycompany:validation:items:StringFormat"
-        scope: Any
+        scopes: [Field, Type]
         typeConstraint:
           allowedSchemaTypes:
             - array
@@ -541,7 +540,7 @@ When the `policy` is set to `SuggestFix`, the `markerscope` linter provides auto
 
 2. **Type constraint violations**: For markers applied to incompatible types, the linter suggests removing the invalid marker.
 
-3. **Named type violations**: For AnyScope markers with type constraints applied to fields using named types, the linter suggests moving the marker to the type definition if the underlying type is compatible with the marker's type constraints.
+3. **Named type violations**: For markers that can be applied to both fields and types with type constraints applied to fields using named types, the linter suggests moving the marker to the type definition if the underlying type is compatible with the marker's type constraints.
 
 When the `policy` is set to `Warn`, violations are reported as warnings without suggesting fixes.
 

pkg/analysis/markerscope/analyzer.go

@@ -173,7 +173,7 @@ func (a *analyzer) checkFieldMarkers(pass *analysis.Pass, field *ast.Field, mark
 		}
 
 		// Check if FieldScope is allowed
-		if !rule.Scope.Allows(FieldScope) {
+		if !rule.AllowsScope(FieldScope) {
 			a.reportFieldScopeViolation(pass, field, marker, rule)
 			continue
 		}
@@ -196,7 +196,7 @@ func (a *analyzer) checkTypeSpecMarkers(pass *analysis.Pass, typeSpec *ast.TypeS
 		}
 
 		// Check if TypeScope is allowed
-		if !rule.Scope.Allows(TypeScope) {
+		if !rule.AllowsScope(TypeScope) {
 			a.reportTypeScopeViolation(pass, typeSpec, marker, rule)
 			continue
 		}
@@ -212,7 +212,7 @@ func (a *analyzer) reportFieldScopeViolation(pass *analysis.Pass, field *ast.Fie
 
 	var fixes []analysis.SuggestedFix
 
-	if rule.Scope == TypeScope {
+	if rule.AllowsScope(TypeScope) {
 		message = fmt.Sprintf("marker %q can only be applied to types", marker.Identifier)
 
 		if a.policy == MarkerScopePolicySuggestFix {
@@ -276,7 +276,7 @@ func (a *analyzer) reportTypeScopeViolation(pass *analysis.Pass, typeSpec *ast.T
 	var fixes []analysis.SuggestedFix
 
 	message := fmt.Sprintf("marker %q cannot be applied to types", marker.Identifier)
-	if rule.Scope == FieldScope {
+	if rule.AllowsScope(FieldScope) {
 		message = fmt.Sprintf("marker %q can only be applied to fields", marker.Identifier)
 
 		if a.policy == MarkerScopePolicySuggestFix {
@@ -347,7 +347,7 @@ func (a *analyzer) validateFieldTypeConstraint(pass *analysis.Pass, field *ast.F
 	}
 
 	// Check if the marker should be on the type definition instead of the field
-	if rule.NamedTypeConstraint == NamedTypeConstraintRequireTypeDefinition && rule.Scope == AnyScope {
+	if rule.NamedTypeConstraint == NamedTypeConstraintRequireTypeDefinition && rule.AllowsScope(TypeScope) {
 		namedType, ok := tv.Type.(*types.Named)
 		if ok {
 			return &markerShouldBeOnTypeDefinitionError{typeName: namedType.Obj().Name()}
@@ -404,7 +404,7 @@ func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint) error {
 
 func (a *analyzer) suggestMoveToField(pass *analysis.Pass, typeSpec *ast.TypeSpec, marker markershelper.Marker, rule MarkerScopeRule) []analysis.SuggestedFix {
 	// Only suggest moving to field if FieldScope is allowed
-	if !rule.Scope.Allows(FieldScope) {
+	if !rule.AllowsScope(FieldScope) {
 		return nil
 	}
 
@@ -444,7 +444,7 @@ func (a *analyzer) suggestMoveToField(pass *analysis.Pass, typeSpec *ast.TypeSpe
 // suggestMoveToFieldsIfCompatible generates suggested fixes to move a marker from type to compatible fields.
 func (a *analyzer) suggestMoveToFieldsIfCompatible(pass *analysis.Pass, field *ast.Field, marker markershelper.Marker, rule MarkerScopeRule) []analysis.SuggestedFix {
 	// Only suggest moving to type if TypeScope is allowed
-	if !rule.Scope.Allows(TypeScope) {
+	if !rule.AllowsScope(TypeScope) {
 		return nil
 	}
 

pkg/analysis/markerscope/analyzer_test.go

@@ -58,29 +58,29 @@ func TestAnalyzerWithCustomAndOverrideMarkers(t *testing.T) {
 			// Override built-in "optional" to allow on types (default is FieldScope only)
 			{
 				Identifier: "optional",
-				Scope:      markerscope.AnyScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.FieldScope, markerscope.TypeScope},
 			},
 			// Override built-in "required" to allow on types (default is FieldScope only)
 			{
 				Identifier: "required",
-				Scope:      markerscope.AnyScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.FieldScope, markerscope.TypeScope},
 			},
 		},
 		CustomMarkers: []markerscope.MarkerScopeRule{
 			// Custom field-only marker
 			{
 				Identifier: "custom:field-only",
-				Scope:      markerscope.FieldScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.FieldScope},
 			},
 			// Custom type-only marker
 			{
 				Identifier: "custom:type-only",
-				Scope:      markerscope.TypeScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.TypeScope},
 			},
 			// Custom marker with string type constraint
 			{
 				Identifier: "custom:string-only",
-				Scope:      markerscope.FieldScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.FieldScope},
 				TypeConstraint: &markerscope.TypeConstraint{
 					AllowedSchemaTypes: []markerscope.SchemaType{
 						markerscope.SchemaTypeString,
@@ -90,7 +90,7 @@ func TestAnalyzerWithCustomAndOverrideMarkers(t *testing.T) {
 			// Custom marker with integer type constraint
 			{
 				Identifier: "custom:integer-only",
-				Scope:      markerscope.FieldScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.FieldScope},
 				TypeConstraint: &markerscope.TypeConstraint{
 					AllowedSchemaTypes: []markerscope.SchemaType{
 						markerscope.SchemaTypeInteger,
@@ -100,7 +100,7 @@ func TestAnalyzerWithCustomAndOverrideMarkers(t *testing.T) {
 			// Custom marker with array of strings constraint
 			{
 				Identifier: "custom:string-array",
-				Scope:      markerscope.FieldScope,
+				Scopes:     []markerscope.ScopeConstraint{markerscope.FieldScope},
 				TypeConstraint: &markerscope.TypeConstraint{
 					AllowedSchemaTypes: []markerscope.SchemaType{
 						markerscope.SchemaTypeArray,

pkg/analysis/markerscope/config.go

@@ -23,17 +23,16 @@ const (
 	FieldScope ScopeConstraint = "Field"
 	// TypeScope indicates the marker can be placed on type definitions.
 	TypeScope ScopeConstraint = "Type"
-	// AnyScope indicates the marker can be placed on either fields or types.
-	AnyScope ScopeConstraint = "Any"
 )
 
-// Allows checks if the given scope is allowed by this constraint.
-func (s ScopeConstraint) Allows(scope ScopeConstraint) bool {
-	if s == AnyScope {
-		return true
+// AllowsScope checks if the given scope is allowed by this rule.
+func (r MarkerScopeRule) AllowsScope(scope ScopeConstraint) bool {
+	for _, s := range r.Scopes {
+		if s == scope {
+			return true
+		}
 	}
-
-	return s == scope
+	return false
 }
 
 // TypeConstraint defines what types a marker can be applied to.
@@ -68,8 +67,9 @@ type MarkerScopeRule struct {
 	// Identifier is the marker identifier (e.g., "optional", "kubebuilder:validation:Minimum").
 	Identifier string `json:"identifier,omitempty"`
 
-	// Scope specifies where the marker can be placed (field vs type).
-	Scope ScopeConstraint
+	// Scopes specifies where the marker can be placed (field, type, or both).
+	// Can contain FieldScope, TypeScope, or both for markers that can be placed anywhere.
+	Scopes []ScopeConstraint `json:"scopes,omitempty"`
 
 	// NamedTypeConstraint specifies how markers should be applied to named types.
 	// When a field uses a named type (e.g., type CustomInt int32), this determines

pkg/analysis/markerscope/initializer.go

@@ -137,16 +137,18 @@ func validateCustomMarkers(rules []MarkerScopeRule, defaultRules map[string]Mark
 
 func validateMarkerRule(rule MarkerScopeRule) error {
 	// Validate scope constraint
-	if rule.Scope == "" {
+	if len(rule.Scopes) == 0 {
 		return errScopeRequired
 	}
 
-	// Validate that scope is a valid value
-	switch rule.Scope {
-	case FieldScope, TypeScope, AnyScope:
-		// Valid scope
-	default:
-		return &invalidScopeConstraintError{scope: string(rule.Scope)}
+	// Validate that each scope is a valid value
+	for _, scope := range rule.Scopes {
+		switch scope {
+		case FieldScope, TypeScope:
+			// Valid scope
+		default:
+			return &invalidScopeConstraintError{scope: string(scope)}
+		}
 	}
 
 	// Validate named type constraint if present