[flake8-pyi] Implement PYI054

crates/ruff/resources/test/fixtures/flake8_pyi/PYI054.py

@@ -0,0 +1,20 @@
+field01: int = 0xFFFFFFFF
+field02: int = 0xFFFFFFFFF
+field03: int = -0xFFFFFFFF
+field04: int = -0xFFFFFFFFF
+
+field05: int = 1234567890
+field06: int = 12_456_890
+field07: int = 12345678901
+field08: int = -1234567801
+field09: int = -234_567_890
+
+field10: float = 123.456789
+field11: float = 123.4567890
+field12: float = -123.456789
+field13: float = -123.567_890
+
+field14: complex = 1e1234567j
+field15: complex = 1e12345678j
+field16: complex = -1e1234567j
+field17: complex = 1e123456789j

crates/ruff/resources/test/fixtures/flake8_pyi/PYI054.pyi

@@ -0,0 +1,20 @@
+field01: int = 0xFFFFFFFF
+field02: int = 0xFFFFFFFFF  # Error: PYI054
+field03: int = -0xFFFFFFFF
+field04: int = -0xFFFFFFFFF  # Error: PYI054
+
+field05: int = 1234567890
+field06: int = 12_456_890
+field07: int = 12345678901  # Error: PYI054
+field08: int = -1234567801
+field09: int = -234_567_890  # Error: PYI054
+
+field10: float = 123.456789
+field11: float = 123.4567890  # Error: PYI054
+field12: float = -123.456789
+field13: float = -123.567_890  # Error: PYI054
+
+field14: complex = 1e1234567j
+field15: complex = 1e12345678j  # Error: PYI054
+field16: complex = -1e1234567j
+field17: complex = 1e123456789j  # Error: PYI054

crates/ruff/src/checkers/ast/mod.rs

@@ -3393,6 +3393,15 @@ where
                     }
                 }
             }
+            Expr::Constant(ast::ExprConstant {
+                value: Constant::Int(_) | Constant::Float(_) | Constant::Complex { .. },
+                range,
+                ..
+            }) => {
+                if self.is_stub && self.enabled(Rule::LongNumericLiteralsInStub) {
+                    flake8_pyi::rules::long_numeric_literals_in_stub(self, *range);
+                }
+            }
             Expr::Constant(ast::ExprConstant {
                 value: Constant::Str(value),
                 kind,

crates/ruff/src/codes.rs

@@ -599,6 +599,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Pyi, "045") => (RuleGroup::Unspecified, Rule::IterMethodReturnIterable),
         (Flake8Pyi, "048") => (RuleGroup::Unspecified, Rule::StubBodyMultipleStatements),
         (Flake8Pyi, "052") => (RuleGroup::Unspecified, Rule::UnannotatedAssignmentInStub),
+        (Flake8Pyi, "054") => (RuleGroup::Unspecified, Rule::LongNumericLiteralsInStub),
 
         // flake8-pytest-style
         (Flake8PytestStyle, "001") => (RuleGroup::Unspecified, Rule::PytestFixtureIncorrectParenthesesStyle),

crates/ruff/src/registry.rs

@@ -522,6 +522,7 @@ ruff_macros::register_rules!(
     rules::flake8_pyi::rules::NonEmptyStubBody,
     rules::flake8_pyi::rules::PassInClassBody,
     rules::flake8_pyi::rules::PassStatementStubBody,
+    rules::flake8_pyi::rules::LongNumericLiteralsInStub,
     rules::flake8_pyi::rules::QuotedAnnotationInStub,
     rules::flake8_pyi::rules::SnakeCaseTypeAlias,
     rules::flake8_pyi::rules::StubBodyMultipleStatements,

crates/ruff/src/rules/flake8_pyi/mod.rs

@@ -30,6 +30,8 @@ mod tests {
     #[test_case(Rule::CollectionsNamedTuple, Path::new("PYI024.pyi"))]
     #[test_case(Rule::IterMethodReturnIterable, Path::new("PYI045.py"))]
     #[test_case(Rule::IterMethodReturnIterable, Path::new("PYI045.pyi"))]
+    #[test_case(Rule::LongNumericLiteralsInStub, Path::new("PYI054.py"))]
+    #[test_case(Rule::LongNumericLiteralsInStub, Path::new("PYI054.pyi"))]
     #[test_case(Rule::NonEmptyStubBody, Path::new("PYI010.py"))]
     #[test_case(Rule::NonEmptyStubBody, Path::new("PYI010.pyi"))]
     #[test_case(Rule::PassInClassBody, Path::new("PYI012.py"))]

crates/ruff/src/rules/flake8_pyi/rules/long_numeric_literals_in_stub.rs

@@ -0,0 +1,30 @@
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_text_size::{TextRange, TextSize};
+
+use ruff_macros::{derive_message_formats, violation};
+
+use crate::checkers::ast::Checker;
+
+#[violation]
+pub struct LongNumericLiteralsInStub;
+
+/// ## What it does
+/// Checks for numeric literals longer than 10 characters
+///
+/// ## Why is this bad?
+/// Long hardcoded numeric values are unlikely to be useful for users. Consider replacing them with ellipses.
+impl Violation for LongNumericLiteralsInStub {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("Numeric literals with a string representation longer than ten characters are not permitted")
+    }
+}
+
+/// PYI054
+pub(crate) fn long_numeric_literals_in_stub(checker: &mut Checker, range: TextRange) {
+    if range.len() > TextSize::new(10) {
+        checker
+            .diagnostics
+            .push(Diagnostic::new(LongNumericLiteralsInStub, range));
+    }
+}

crates/ruff/src/rules/flake8_pyi/rules/mod.rs

@@ -11,6 +11,9 @@ pub(crate) use ellipsis_in_non_empty_class_body::{
 pub(crate) use iter_method_return_iterable::{
     iter_method_return_iterable, IterMethodReturnIterable,
 };
+pub(crate) use long_numeric_literals_in_stub::{
+    long_numeric_literals_in_stub, LongNumericLiteralsInStub,
+};
 pub(crate) use non_empty_stub_body::{non_empty_stub_body, NonEmptyStubBody};
 pub(crate) use pass_in_class_body::{pass_in_class_body, PassInClassBody};
 pub(crate) use pass_statement_stub_body::{pass_statement_stub_body, PassStatementStubBody};
@@ -39,6 +42,7 @@ mod docstring_in_stubs;
 mod duplicate_union_member;
 mod ellipsis_in_non_empty_class_body;
 mod iter_method_return_iterable;
+mod long_numeric_literals_in_stub;
 mod non_empty_stub_body;
 mod pass_in_class_body;
 mod pass_statement_stub_body;

crates/ruff/src/rules/flake8_pyi/rules/simple_defaults.rs

@@ -132,55 +132,37 @@ fn is_valid_default_value_with_annotation(
             value: Constant::Bytes(..),
             ..
         }) => return locator.slice(default.range()).len() <= 50,
-        // Ex) `123`, `True`, `False`, `3.14`
+        // Ex) `123`, `True`, `False`, `3.14`, `2j`
         Expr::Constant(ast::ExprConstant {
-            value: Constant::Int(..) | Constant::Bool(..) | Constant::Float(..),
+            value:
+                Constant::Int(..) | Constant::Bool(..) | Constant::Float(..) | Constant::Complex { .. },
             ..
         }) => {
-            return locator.slice(default.range()).len() <= 10;
-        }
-        // Ex) `2j`
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Complex { real, .. },
-            ..
-        }) => {
-            if *real == 0.0 {
-                return locator.slice(default.range()).len() <= 10;
-            }
+            return true;
         }
         Expr::UnaryOp(ast::ExprUnaryOp {
             op: Unaryop::USub,
             operand,
             range: _,
         }) => {
-            // Ex) `-1`, `-3.14`
-            if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Int(..) | Constant::Float(..),
-                ..
-            }) = operand.as_ref()
-            {
-                return locator.slice(operand.range()).len() <= 10;
-            }
-            // Ex) `-2j`
-            if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Complex { real, .. },
-                ..
-            }) = operand.as_ref()
-            {
-                if *real == 0.0 {
-                    return locator.slice(operand.range()).len() <= 10;
-                }
-            }
-            // Ex) `-math.inf`, `-math.pi`, etc.
-            if let Expr::Attribute(_) = operand.as_ref() {
-                if model.resolve_call_path(operand).map_or(false, |call_path| {
-                    ALLOWED_MATH_ATTRIBUTES_IN_DEFAULTS.iter().any(|target| {
-                        // reject `-math.nan`
-                        call_path.as_slice() == *target && *target != ["math", "nan"]
-                    })
-                }) {
-                    return true;
+            match operand.as_ref() {
+                // Ex) `-1`, `-3.14`, `2j`
+                Expr::Constant(ast::ExprConstant {
+                    value: Constant::Int(..) | Constant::Float(..) | Constant::Complex { .. },
+                    ..
+                }) => return true,
+                // Ex) `-math.inf`, `-math.pi`, etc.
+                Expr::Attribute(_) => {
+                    if model.resolve_call_path(operand).map_or(false, |call_path| {
+                        ALLOWED_MATH_ATTRIBUTES_IN_DEFAULTS.iter().any(|target| {
+                            // reject `-math.nan`
+                            call_path.as_slice() == *target && *target != ["math", "nan"]
+                        })
+                    }) {
+                        return true;
+                    }
                 }
+                _ => {}
             }
         }
         Expr::BinOp(ast::ExprBinOp {

crates/ruff/src/rules/flake8_pyi/snapshots/ruff__rules__flake8_pyi__tests__PYI054_PYI054.py.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff/src/rules/flake8_pyi/mod.rs
+---
+

crates/ruff/src/rules/flake8_pyi/snapshots/ruff__rules__flake8_pyi__tests__PYI054_PYI054.pyi.snap

@@ -0,0 +1,79 @@
+---
+source: crates/ruff/src/rules/flake8_pyi/mod.rs
+---
+PYI054.pyi:2:16: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+  |
+2 | field01: int = 0xFFFFFFFF
+3 | field02: int = 0xFFFFFFFFF  # Error: PYI054
+  |                ^^^^^^^^^^^ PYI054
+4 | field03: int = -0xFFFFFFFF
+5 | field04: int = -0xFFFFFFFFF  # Error: PYI054
+  |
+
+PYI054.pyi:4:17: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+  |
+4 | field02: int = 0xFFFFFFFFF  # Error: PYI054
+5 | field03: int = -0xFFFFFFFF
+6 | field04: int = -0xFFFFFFFFF  # Error: PYI054
+  |                 ^^^^^^^^^^^ PYI054
+7 | 
+8 | field05: int = 1234567890
+  |
+
+PYI054.pyi:8:16: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+   |
+ 8 | field05: int = 1234567890
+ 9 | field06: int = 12_456_890
+10 | field07: int = 12345678901  # Error: PYI054
+   |                ^^^^^^^^^^^ PYI054
+11 | field08: int = -1234567801
+12 | field09: int = -234_567_890  # Error: PYI054
+   |
+
+PYI054.pyi:10:17: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+   |
+10 | field07: int = 12345678901  # Error: PYI054
+11 | field08: int = -1234567801
+12 | field09: int = -234_567_890  # Error: PYI054
+   |                 ^^^^^^^^^^^ PYI054
+13 | 
+14 | field10: float = 123.456789
+   |
+
+PYI054.pyi:13:18: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+   |
+13 | field10: float = 123.456789
+14 | field11: float = 123.4567890  # Error: PYI054
+   |                  ^^^^^^^^^^^ PYI054
+15 | field12: float = -123.456789
+16 | field13: float = -123.567_890  # Error: PYI054
+   |
+
+PYI054.pyi:15:19: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+   |
+15 | field11: float = 123.4567890  # Error: PYI054
+16 | field12: float = -123.456789
+17 | field13: float = -123.567_890  # Error: PYI054
+   |                   ^^^^^^^^^^^ PYI054
+18 | 
+19 | field14: complex = 1e1234567j
+   |
+
+PYI054.pyi:18:20: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+   |
+18 | field14: complex = 1e1234567j
+19 | field15: complex = 1e12345678j  # Error: PYI054
+   |                    ^^^^^^^^^^^ PYI054
+20 | field16: complex = -1e1234567j
+21 | field17: complex = 1e123456789j  # Error: PYI054
+   |
+
+PYI054.pyi:20:20: PYI054 Numeric literals with a string representation longer than ten characters are not permitted
+   |
+20 | field15: complex = 1e12345678j  # Error: PYI054
+21 | field16: complex = -1e1234567j
+22 | field17: complex = 1e123456789j  # Error: PYI054
+   |                    ^^^^^^^^^^^^ PYI054
+   |
+
+