refactor(markerscope): remove support for float/number types

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

Author: nayuta723

pkg/analysis/markerscope/analyzer.go

@@ -49,9 +49,8 @@ func init() {
 }
 
 type analyzer struct {
-	markerRules         map[string]MarkerScopeRule
-	policy              MarkerScopePolicy
-	allowDangerousTypes bool
+	markerRules map[string]MarkerScopeRule
+	policy      MarkerScopePolicy
 }
 
 // newAnalyzer creates a new analyzer.
@@ -78,9 +77,8 @@ func newAnalyzer(cfg *MarkerScopeConfig) *analysis.Analyzer {
 	maps.Copy(rules, customRules)   // Add custom markers
 
 	a := &analyzer{
-		markerRules:         rules,
-		policy:              cfg.Policy,
-		allowDangerousTypes: cfg.AllowDangerousTypes,
+		markerRules: rules,
+		policy:      cfg.Policy,
 	}
 
 	// Register all markers (both default and custom) with the markers helper
@@ -122,7 +120,6 @@ func defaultConfig(cfg *MarkerScopeConfig) {
 	if cfg.Policy == "" {
 		cfg.Policy = MarkerScopePolicyWarn
 	}
-	// allowDangerousTypes defaults to false (zero value)
 	// overrideMarkers and customMarkers default to empty (zero value)
 }
 
@@ -211,7 +208,7 @@ func (a *analyzer) checkSingleTypeMarkers(pass *analysis.Pass, typeSpec *ast.Typ
 		}
 
 		// Check type constraints if present
-		a.checkTypeConstraintViolation(pass, typeSpec, marker, rule, a.allowDangerousTypes)
+		a.checkTypeConstraintViolation(pass, typeSpec, marker, rule)
 	}
 }
 
@@ -242,7 +239,7 @@ func (a *analyzer) reportFieldScopeViolation(pass *analysis.Pass, field *ast.Fie
 
 // checkFieldTypeConstraintViolation checks and reports type constraint violations for field markers.
 func (a *analyzer) checkFieldTypeConstraintViolation(pass *analysis.Pass, field *ast.Field, marker markershelper.Marker, rule MarkerScopeRule) {
-	if err := a.validateFieldTypeConstraint(pass, field, rule, a.allowDangerousTypes); err != nil {
+	if err := a.validateFieldTypeConstraint(pass, field, rule); err != nil {
 		var fixes []analysis.SuggestedFix
 
 		if a.policy == MarkerScopePolicySuggestFix {
@@ -301,8 +298,8 @@ func (a *analyzer) reportTypeScopeViolation(pass *analysis.Pass, typeSpec *ast.T
 }
 
 // checkTypeConstraintViolation checks and reports type constraint violations.
-func (a *analyzer) checkTypeConstraintViolation(pass *analysis.Pass, typeSpec *ast.TypeSpec, marker markershelper.Marker, rule MarkerScopeRule, allowDangerousTypes bool) {
-	if err := a.validateTypeSpecTypeConstraint(pass, typeSpec, rule.TypeConstraint, allowDangerousTypes); err != nil {
+func (a *analyzer) checkTypeConstraintViolation(pass *analysis.Pass, typeSpec *ast.TypeSpec, marker markershelper.Marker, rule MarkerScopeRule) {
+	if err := a.validateTypeSpecTypeConstraint(pass, typeSpec, rule.TypeConstraint); err != nil {
 		var fixes []analysis.SuggestedFix
 
 		if a.policy == MarkerScopePolicySuggestFix {
@@ -339,14 +336,14 @@ func (a *analyzer) checkTypeConstraintViolation(pass *analysis.Pass, typeSpec *a
 }
 
 // validateFieldTypeConstraint validates that a field's type matches the type constraint.
-func (a *analyzer) validateFieldTypeConstraint(pass *analysis.Pass, field *ast.Field, rule MarkerScopeRule, allowDangerousTypes bool) error {
+func (a *analyzer) validateFieldTypeConstraint(pass *analysis.Pass, field *ast.Field, rule MarkerScopeRule) error {
 	// Get the type of the field
 	tv, ok := pass.TypesInfo.Types[field.Type]
 	if !ok {
 		return nil // Skip if we can't determine the type
 	}
 
-	if err := validateTypeAgainstConstraint(tv.Type, rule.TypeConstraint, allowDangerousTypes); err != nil {
+	if err := validateTypeAgainstConstraint(tv.Type, rule.TypeConstraint); err != nil {
 		return err
 	}
 
@@ -361,7 +358,7 @@ func (a *analyzer) validateFieldTypeConstraint(pass *analysis.Pass, field *ast.F
 }
 
 // validateTypeSpecTypeConstraint validates that a type spec's type matches the type constraint.
-func (a *analyzer) validateTypeSpecTypeConstraint(pass *analysis.Pass, typeSpec *ast.TypeSpec, tc *TypeConstraint, allowDangerousTypes bool) error {
+func (a *analyzer) validateTypeSpecTypeConstraint(pass *analysis.Pass, typeSpec *ast.TypeSpec, tc *TypeConstraint) error {
 	// Get the type of the type spec
 	obj := pass.TypesInfo.Defs[typeSpec.Name]
 	if obj == nil {
@@ -373,21 +370,14 @@ func (a *analyzer) validateTypeSpecTypeConstraint(pass *analysis.Pass, typeSpec
 		return nil
 	}
 
-	return validateTypeAgainstConstraint(typeName.Type(), tc, allowDangerousTypes)
+	return validateTypeAgainstConstraint(typeName.Type(), tc)
 }
 
 // validateTypeAgainstConstraint validates that a Go type satisfies the type constraint.
-func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint, allowDangerousTypes bool) error {
+func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint) error {
 	// Get the schema type from the Go type
 	schemaType := getSchemaType(t)
 
-	// Check if dangerous types are disallowed
-	if !allowDangerousTypes && schemaType == SchemaTypeNumber {
-		// Get the underlying type for better error messages
-		underlyingType := getUnderlyingType(t)
-		return &DengerousTypeError{Type: underlyingType.String()}
-	}
-
 	if tc == nil {
 		return nil
 	}
@@ -403,7 +393,7 @@ func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint, allowDanger
 	if tc.ElementConstraint != nil && schemaType == SchemaTypeArray {
 		elemType := getElementType(t)
 		if elemType != nil {
-			if err := validateTypeAgainstConstraint(elemType, tc.ElementConstraint, allowDangerousTypes); err != nil {
+			if err := validateTypeAgainstConstraint(elemType, tc.ElementConstraint); err != nil {
 				return &InvalidElementConstraintError{Err: err}
 			}
 		}

pkg/analysis/markerscope/analyzer_test.go

@@ -26,7 +26,6 @@ func TestAnalyzerWithDefaultConfig(t *testing.T) {
 	testdata := analysistest.TestData()
 	// Test with nil config - should use all defaults:
 	// - Policy: Warn
-	// - AllowDangerousTypes: false
 	// - OverrideMarkers: empty (use built-in defaults)
 	// - CustomMarkers: empty
 	analyzer, err := markerscope.Initializer().Init(&markerscope.MarkerScopeConfig{})

pkg/analysis/markerscope/config.go

@@ -108,11 +108,6 @@ type MarkerScopeConfig struct {
 	//         allowedSchemaTypes: ["string"]
 	CustomMarkers []MarkerScopeRule `json:"customMarkers,omitempty"`
 
-	// AllowDangerousTypes specifies if dangerous types are allowed.
-	// If true, dangerous types are allowed.
-	// If false, dangerous types are not allowed.
-	AllowDangerousTypes bool `json:"allowDangerousTypes,omitempty"`
-
 	// Policy determines whether to suggest fixes or just warn.
 	Policy MarkerScopePolicy `json:"policy,omitempty"`
 }
@@ -196,35 +191,35 @@ func addNumericMarkers(rules map[string]MarkerScopeRule) {
 			Scope:                AnyScope,
 			StrictTypeConstraint: true,
 			TypeConstraint: &TypeConstraint{
-				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 			},
 		},
 		markers.KubebuilderMaximumMarker: {
 			Scope:                AnyScope,
 			StrictTypeConstraint: true,
 			TypeConstraint: &TypeConstraint{
-				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 			},
 		},
 		markers.KubebuilderExclusiveMaximumMarker: {
 			Scope:                AnyScope,
 			StrictTypeConstraint: true,
 			TypeConstraint: &TypeConstraint{
-				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 			},
 		},
 		markers.KubebuilderExclusiveMinimumMarker: {
 			Scope:                AnyScope,
 			StrictTypeConstraint: true,
 			TypeConstraint: &TypeConstraint{
-				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 			},
 		},
 		markers.KubebuilderMultipleOfMarker: {
 			Scope:                AnyScope,
 			StrictTypeConstraint: true,
 			TypeConstraint: &TypeConstraint{
-				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+				AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 			},
 		},
 	}
@@ -392,7 +387,7 @@ func addArrayItemsNumericMarkers(rules map[string]MarkerScopeRule) {
 			TypeConstraint: &TypeConstraint{
 				AllowedSchemaTypes: []SchemaType{SchemaTypeArray},
 				ElementConstraint: &TypeConstraint{
-					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 				},
 			},
 		},
@@ -402,7 +397,7 @@ func addArrayItemsNumericMarkers(rules map[string]MarkerScopeRule) {
 			TypeConstraint: &TypeConstraint{
 				AllowedSchemaTypes: []SchemaType{SchemaTypeArray},
 				ElementConstraint: &TypeConstraint{
-					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 				},
 			},
 		},
@@ -412,7 +407,7 @@ func addArrayItemsNumericMarkers(rules map[string]MarkerScopeRule) {
 			TypeConstraint: &TypeConstraint{
 				AllowedSchemaTypes: []SchemaType{SchemaTypeArray},
 				ElementConstraint: &TypeConstraint{
-					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 				},
 			},
 		},
@@ -422,7 +417,7 @@ func addArrayItemsNumericMarkers(rules map[string]MarkerScopeRule) {
 			TypeConstraint: &TypeConstraint{
 				AllowedSchemaTypes: []SchemaType{SchemaTypeArray},
 				ElementConstraint: &TypeConstraint{
-					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 				},
 			},
 		},
@@ -432,7 +427,7 @@ func addArrayItemsNumericMarkers(rules map[string]MarkerScopeRule) {
 			TypeConstraint: &TypeConstraint{
 				AllowedSchemaTypes: []SchemaType{SchemaTypeArray},
 				ElementConstraint: &TypeConstraint{
-					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger, SchemaTypeNumber},
+					AllowedSchemaTypes: []SchemaType{SchemaTypeInteger},
 				},
 			},
 		},

pkg/analysis/markerscope/errors.go

@@ -69,15 +69,6 @@ func (e *MarkerShouldBeOnTypeDefinitionError) Error() string {
 	return fmt.Sprintf("marker should be declared on the type definition of %s instead of the field", e.TypeName)
 }
 
-// DengerousTypeError represents an error when a dangerous type is used.
-type DengerousTypeError struct {
-	Type string
-}
-
-func (e *DengerousTypeError) Error() string {
-	return fmt.Sprintf("type %s is dangerous and not allowed (set allowDangerousTypes to true to permit)", e.Type)
-}
-
 // TypeNotAllowedError represents an error when a type is not allowed.
 type TypeNotAllowedError struct {
 	Type         SchemaType

pkg/analysis/markerscope/initializer.go

@@ -157,7 +157,7 @@ func validateTypeConstraint(tc *TypeConstraint) error {
 
 func isValidSchemaType(st SchemaType) bool {
 	switch st {
-	case SchemaTypeInteger, SchemaTypeNumber, SchemaTypeString, SchemaTypeBoolean, SchemaTypeArray, SchemaTypeObject:
+	case SchemaTypeInteger, SchemaTypeString, SchemaTypeBoolean, SchemaTypeArray, SchemaTypeObject:
 		return true
 	default:
 		return false

pkg/analysis/markerscope/initializer_test.go

@@ -166,7 +166,6 @@ var _ = Describe("markerscope initializer", func() {
 							TypeConstraint: &markerscope.TypeConstraint{
 								AllowedSchemaTypes: []markerscope.SchemaType{
 									markerscope.SchemaTypeInteger,
-									markerscope.SchemaTypeNumber,
 								},
 							},
 						},

pkg/analysis/markerscope/schema.go

@@ -23,8 +23,6 @@ type SchemaType string
 const (
 	// SchemaTypeInteger represents integer types (int, int32, int64, uint, etc.)
 	SchemaTypeInteger SchemaType = "integer"
-	// SchemaTypeNumber represents floating-point types (float32, float64).
-	SchemaTypeNumber SchemaType = "number"
 	// SchemaTypeString represents string types.
 	SchemaTypeString SchemaType = "string"
 	// SchemaTypeBoolean represents boolean types.
@@ -74,11 +72,9 @@ func getBasicTypeSchema(bt *types.Basic) SchemaType {
 	case types.Int, types.Int8, types.Int16, types.Int32, types.Int64,
 		types.Uint, types.Uint8, types.Uint16, types.Uint32, types.Uint64:
 		return SchemaTypeInteger
-	case types.Float32, types.Float64:
-		return SchemaTypeNumber
 	case types.String:
 		return SchemaTypeString
-	case types.Invalid, types.Uintptr, types.Complex64, types.Complex128,
+	case types.Float32, types.Float64, types.Invalid, types.Uintptr, types.Complex64, types.Complex128,
 		types.UnsafePointer, types.UntypedBool, types.UntypedInt, types.UntypedRune,
 		types.UntypedFloat, types.UntypedComplex, types.UntypedString, types.UntypedNil:
 		// These types are not supported in OpenAPI schemas

pkg/analysis/markerscope/testdata/src/a/items.go

@@ -47,7 +47,7 @@ type ObjectArrayTypeNoMarker []map[string]string
 type GeneralArrayTypeNoMarker []string
 
 // Invalid: items:Maximum on string array type
-// +kubebuilder:validation:items:Maximum=100 // want `marker "kubebuilder:validation:items:Maximum": array element: type string is not allowed \(expected one of: \[integer number\]\)`
+// +kubebuilder:validation:items:Maximum=100 // want `marker "kubebuilder:validation:items:Maximum": array element: type string is not allowed \(expected one of: \[integer\]\)`
 type InvalidItemsMaximumOnStringArrayType []string
 
 // Invalid: items:Pattern on int array type
@@ -128,7 +128,7 @@ type ArrayItemsMarkersFieldTest struct {
 	InvalidItemsFormatOnGeneralArrayType GeneralArrayTypeNoMarker `json:"invalidItemsFormatOnGeneralArrayType"`
 
 	// Invalid: items:Maximum on string array (element type mismatch)
-	// +kubebuilder:validation:items:Maximum=100 // want `marker "kubebuilder:validation:items:Maximum": array element: type string is not allowed \(expected one of: \[integer number\]\)`
+	// +kubebuilder:validation:items:Maximum=100 // want `marker "kubebuilder:validation:items:Maximum": array element: type string is not allowed \(expected one of: \[integer\]\)`
 	InvalidItemsMaximumOnStringArray []string `json:"invalidItemsMaximumOnStringArray"`
 
 	// Invalid: items:Pattern on int array (element type mismatch)

pkg/analysis/markerscope/testdata/src/a/numeric.go

@@ -30,17 +30,17 @@ type MaximumType int64
 // +kubebuilder:validation:MultipleOf=3
 type MultipleOfType int32
 
-// Valid: Float type with numeric markers
-// +kubebuilder:validation:Minimum=0.0 // want `marker "kubebuilder:validation:Minimum": type float64 is dangerous and not allowed \(set allowDangerousTypes to true to permit\)`
-// +kubebuilder:validation:Maximum=1.0 // want `marker "kubebuilder:validation:Maximum": type float64 is dangerous and not allowed \(set allowDangerousTypes to true to permit\)`
+// Invalid: Float type with numeric markers (float types are not supported)
+// +kubebuilder:validation:Minimum=0.0 // want `marker "kubebuilder:validation:Minimum": type  is not allowed \(expected one of: \[integer\]\)`
+// +kubebuilder:validation:Maximum=1.0 // want `marker "kubebuilder:validation:Maximum": type  is not allowed \(expected one of: \[integer\]\)`
 type FloatType float64
 
 // Invalid: Minimum marker on string type
-// +kubebuilder:validation:Minimum=0 // want `marker "kubebuilder:validation:Minimum": type string is not allowed \(expected one of: \[integer number\]\)`
+// +kubebuilder:validation:Minimum=0 // want `marker "kubebuilder:validation:Minimum": type string is not allowed \(expected one of: \[integer\]\)`
 type InvalidMinimumOnStringType string
 
 // Invalid: Maximum marker on boolean type
-// +kubebuilder:validation:Maximum=100 // want `marker "kubebuilder:validation:Maximum": type boolean is not allowed \(expected one of: \[integer number\]\)`
+// +kubebuilder:validation:Maximum=100 // want `marker "kubebuilder:validation:Maximum": type boolean is not allowed \(expected one of: \[integer\]\)`
 type InvalidMaximumOnBoolType bool
 
 type NumericMarkersFieldTest struct {
@@ -107,20 +107,20 @@ type NumericMarkersFieldTest struct {
 	InvalidMultipleOfOnNumericType NumericType `json:"invalidMultipleOfOnNumericType"`
 
 	// Invalid: Minimum marker on string field
-	// +kubebuilder:validation:Minimum=0 // want `marker "kubebuilder:validation:Minimum": type string is not allowed \(expected one of: \[integer number\]\)`
+	// +kubebuilder:validation:Minimum=0 // want `marker "kubebuilder:validation:Minimum": type string is not allowed \(expected one of: \[integer\]\)`
 	InvalidMinimumOnString string `json:"invalidMinimumOnString"`
 
 	// Invalid: Maximum marker on boolean field
-	// +kubebuilder:validation:Maximum=100 // want `marker "kubebuilder:validation:Maximum": type boolean is not allowed \(expected one of: \[integer number\]\)`
+	// +kubebuilder:validation:Maximum=100 // want `marker "kubebuilder:validation:Maximum": type boolean is not allowed \(expected one of: \[integer\]\)`
 	InvalidMaximumOnBool bool `json:"invalidMaximumOnBool"`
 
 	// Invalid: MultipleOf marker on array field
-	// +kubebuilder:validation:MultipleOf=5 // want `marker "kubebuilder:validation:MultipleOf": type array is not allowed \(expected one of: \[integer number\]\)`
+	// +kubebuilder:validation:MultipleOf=5 // want `marker "kubebuilder:validation:MultipleOf": type array is not allowed \(expected one of: \[integer\]\)`
 	InvalidMultipleOfOnArray []int32 `json:"invalidMultipleOfOnArray"`
 
 	// Invalid: Using invalid named type
-	// +kubebuilder:validation:Minimum=50 // want `marker "kubebuilder:validation:Minimum": type string is not allowed \(expected one of: \[integer number\]\)`
-	// +kubebuilder:validation:Maximum=100 // want `marker "kubebuilder:validation:Maximum": type string is not allowed \(expected one of: \[integer number\]\)`
+	// +kubebuilder:validation:Minimum=50 // want `marker "kubebuilder:validation:Minimum": type string is not allowed \(expected one of: \[integer\]\)`
+	// +kubebuilder:validation:Maximum=100 // want `marker "kubebuilder:validation:Maximum": type string is not allowed \(expected one of: \[integer\]\)`
 	InvalidMinimumOnStringTyped InvalidMinimumOnStringType `json:"invalidMinimumOnStringTyped"`
 
 	// Invalid: Using invalid named type

pkg/analysis/markerscope/testdata/src/a/numeric.go.golden

@@ -35,7 +35,7 @@ type MaximumType int64
 // +kubebuilder:validation:MultipleOf=3
 type MultipleOfType int32
 
-// Valid: Float type with numeric markers
+// Invalid: Float type with numeric markers (float types are not supported)
 type FloatType float64
 
 // Invalid: Minimum marker on string type