Uplift clippy::zero_prefixed_literal

Author: GrigorenkoPV

compiler/rustc_lint/messages.ftl

@@ -464,6 +464,10 @@ lint_invalid_reference_casting_note_book = for more information, visit <https://
 
 lint_invalid_reference_casting_note_ty_has_interior_mutability = even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get`
 
+lint_leading_zeros_in_decimal_literals = this is a decimal constant
+    .suggestion_remove_zeros = if you meant to use a decimal constant, remove leading zeros to avoid confusion
+    .suggestion_prefix_octal = if you meant to use an octal constant, prefix it with `0o` instead
+
 lint_legacy_derive_helpers = derive helper attribute is used before it is introduced
     .label = the attribute is introduced here
 

compiler/rustc_lint/src/builtin.rs

@@ -59,7 +59,7 @@ use crate::lints::{
     BuiltinTrivialBounds, BuiltinTypeAliasBounds, BuiltinUngatedAsyncFnTrackCaller,
     BuiltinUnpermittedTypeInit, BuiltinUnpermittedTypeInitSub, BuiltinUnreachablePub,
     BuiltinUnsafe, BuiltinUnstableFeatures, BuiltinUnusedDocComment, BuiltinUnusedDocCommentSub,
-    BuiltinWhileTrue, InvalidAsmLabel,
+    BuiltinWhileTrue, InvalidAsmLabel, LeadingZeros,
 };
 use crate::nonstandard_style::{MethodLateContext, method_context};
 use crate::{
@@ -3061,3 +3061,69 @@ impl EarlyLintPass for SpecialModuleName {
         }
     }
 }
+
+// TODO: rewrite to match rustc's style instead of clippy's
+declare_lint! {
+    /// ### What it does
+    /// Warns if an integral constant literal starts with `0`.
+    ///
+    /// ### Why is this bad?
+    /// In some languages (including the infamous C language and most of its family),
+    /// this marks an octal constant. In Rust however, this is a decimal constant.
+    /// This could be confusing for both the writer and a reader of the constant.
+    ///
+    /// ### Example
+    ///
+    /// In Rust:
+    /// ```no_run
+    /// fn main() {
+    ///     let a = 0123;
+    ///     println!("{}", a);
+    /// }
+    /// ```
+    ///
+    /// prints `123`, while in C:
+    ///
+    /// ```c
+    /// #include <stdio.h>
+    ///
+    /// int main() {
+    ///     int a = 0123;
+    ///     printf("%d\n", a);
+    /// }
+    /// ```
+    ///
+    /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
+    pub LEADING_ZEROS_IN_DECIMAL_LITERALS,
+    Warn,
+    "leading `0` in decimal integer literals",
+}
+
+declare_lint_pass!(LeadingZerosInDecimals => [LEADING_ZEROS_IN_DECIMAL_LITERALS]);
+
+impl EarlyLintPass for LeadingZerosInDecimals {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
+        if let ExprKind::Lit(literal) = expr.kind
+            && let token::Lit { kind: token::LitKind::Integer, symbol, suffix: _ } = literal
+            && let s = symbol.as_str()
+            && let Some(tail) = s.strip_prefix('0')
+            && !tail.starts_with(['b', 'o', 'x'])
+            && let nonzero_digits = tail.trim_start_matches(['0', '_'])
+            && !nonzero_digits.is_empty()
+        {
+            let lit_span = expr.span;
+            let zeros_offset = s.len() - nonzero_digits.len();
+            let leading_zeros_span = lit_span.with_hi(lit_span.lo() + BytePos(zeros_offset as u32));
+            let can_be_octal = !nonzero_digits.contains(['8', '9']);
+            let (remove_zeros_applicability, prefix_octal) = if can_be_octal {
+                (Applicability::MaybeIncorrect, Some(lit_span.with_hi(lit_span.lo() + BytePos(1))))
+            } else {
+                (Applicability::MachineApplicable, None)
+            };
+            cx.emit_span_lint(LEADING_ZEROS_IN_DECIMAL_LITERALS, lit_span, LeadingZeros {
+                remove_zeros: (leading_zeros_span, remove_zeros_applicability),
+                prefix_octal,
+            });
+        }
+    }
+}

compiler/rustc_lint/src/lib.rs

@@ -179,6 +179,7 @@ early_lint_methods!(
             UnusedDocComment: UnusedDocComment,
             Expr2024: Expr2024,
             Precedence: Precedence,
+            LeadingZerosInDecimals: LeadingZerosInDecimals,
         ]
     ]
 );

compiler/rustc_lint/src/lints.rs

@@ -3059,3 +3059,13 @@ pub(crate) struct ReservedString {
     #[suggestion(code = " ", applicability = "machine-applicable")]
     pub suggestion: Span,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(lint_leading_zeros_in_decimal_literals)]
+
+pub(crate) struct LeadingZeros {
+    #[suggestion(lint_suggestion_remove_zeros, code = "")]
+    pub remove_zeros: (Span, Applicability),
+    #[suggestion(lint_suggestion_prefix_octal, code = "0o", applicability = "maybe-incorrect")]
+    pub prefix_octal: Option<Span>,
+}

src/tools/clippy/clippy_lints/src/declared_lints.rs

@@ -510,7 +510,6 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::misc_early::UNNEEDED_FIELD_PATTERN_INFO,
     crate::misc_early::UNNEEDED_WILDCARD_PATTERN_INFO,
     crate::misc_early::UNSEPARATED_LITERAL_SUFFIX_INFO,
-    crate::misc_early::ZERO_PREFIXED_LITERAL_INFO,
     crate::mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER_INFO,
     crate::missing_assert_message::MISSING_ASSERT_MESSAGE_INFO,
     crate::missing_asserts_for_indexing::MISSING_ASSERTS_FOR_INDEXING_INFO,

src/tools/clippy/clippy_lints/src/deprecated_lints.rs

@@ -177,5 +177,7 @@ declare_with_version! { RENAMED(RENAMED_VERSION): &[(&str, &str)] = &[
     ("clippy::vtable_address_comparisons", "ambiguous_wide_pointer_comparisons"),
     #[clippy::version = ""]
     ("clippy::reverse_range_loop", "clippy::reversed_empty_ranges"),
+    #[clippy::version = "CURRENT_RUSTC_VERSION"]
+    ("clippy::zero_prefixed_literal", "leading_zeros_in_decimal_literals"),
     // end renamed lints. used by `cargo dev rename_lint`
 ]}

src/tools/clippy/clippy_lints/src/misc_early/mod.rs

@@ -6,7 +6,6 @@ mod redundant_at_rest_pattern;
 mod redundant_pattern;
 mod unneeded_field_pattern;
 mod unneeded_wildcard_pattern;
-mod zero_prefixed_literal;
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet_opt;
@@ -188,45 +187,6 @@ declare_clippy_lint! {
     "literals whose suffix is separated by an underscore"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Warns if an integral constant literal starts with `0`.
-    ///
-    /// ### Why is this bad?
-    /// In some languages (including the infamous C language
-    /// and most of its
-    /// family), this marks an octal constant. In Rust however, this is a decimal
-    /// constant. This could
-    /// be confusing for both the writer and a reader of the constant.
-    ///
-    /// ### Example
-    ///
-    /// In Rust:
-    /// ```no_run
-    /// fn main() {
-    ///     let a = 0123;
-    ///     println!("{}", a);
-    /// }
-    /// ```
-    ///
-    /// prints `123`, while in C:
-    ///
-    /// ```c
-    /// #include <stdio.h>
-    ///
-    /// int main() {
-    ///     int a = 0123;
-    ///     printf("%d\n", a);
-    /// }
-    /// ```
-    ///
-    /// prints `83` (as `83 == 0o123` while `123 == 0o173`).
-    #[clippy::version = "pre 1.29.0"]
-    pub ZERO_PREFIXED_LITERAL,
-    complexity,
-    "integer literals starting with `0`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Warns if a generic shadows a built-in type.
@@ -356,7 +316,6 @@ declare_lint_pass!(MiscEarlyLints => [
     MIXED_CASE_HEX_LITERALS,
     UNSEPARATED_LITERAL_SUFFIX,
     SEPARATED_LITERAL_SUFFIX,
-    ZERO_PREFIXED_LITERAL,
     BUILTIN_TYPE_SHADOW,
     REDUNDANT_PATTERN,
     UNNEEDED_WILDCARD_PATTERN,
@@ -432,7 +391,7 @@ impl MiscEarlyLints {
         };
 
         let lit_kind = LitKind::from_token_lit(lit);
-        if let Ok(LitKind::Int(value, lit_int_type)) = lit_kind {
+        if let Ok(LitKind::Int(_value, lit_int_type)) = lit_kind {
             let suffix = match lit_int_type {
                 LitIntType::Signed(ty) => ty.name_str(),
                 LitIntType::Unsigned(ty) => ty.name_str(),
@@ -441,10 +400,6 @@ impl MiscEarlyLints {
             literal_suffix::check(cx, span, &lit_snip, suffix, "integer");
             if lit_snip.starts_with("0x") {
                 mixed_case_hex_literals::check(cx, span, suffix, &lit_snip);
-            } else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
-                // nothing to do
-            } else if value != 0 && lit_snip.starts_with('0') {
-                zero_prefixed_literal::check(cx, span, &lit_snip);
             }
         } else if let Ok(LitKind::Float(_, LitFloatType::Suffixed(float_ty))) = lit_kind {
             let suffix = float_ty.name_str();

src/tools/clippy/clippy_lints/src/misc_early/zero_prefixed_literal.rs

@@ -0,0 +1,12 @@
+//@ check-pass
+//@ run-rustfix
+//@ rustfix-only-machine-applicable
+
+fn main() {
+    let _ = 0111; //~ WARNING [leading_zeros_in_decimal_literals]
+    let _ = 0007; //~ WARNING [leading_zeros_in_decimal_literals]
+    let _ = 8; //~ WARNING [leading_zeros_in_decimal_literals]
+    let _ = 0_0_;
+    let _ = 00;
+    let _ = 0;
+}

tests/ui/lint/leading-zeros-in-decimal-literals.fixed

@@ -0,0 +1,12 @@
+//@ check-pass
+//@ run-rustfix
+//@ rustfix-only-machine-applicable
+
+fn main() {
+    let _ = 0111; //~ WARNING [leading_zeros_in_decimal_literals]
+    let _ = 0007; //~ WARNING [leading_zeros_in_decimal_literals]
+    let _ = 0008; //~ WARNING [leading_zeros_in_decimal_literals]
+    let _ = 0_0_;
+    let _ = 00;
+    let _ = 0;
+}

tests/ui/lint/leading-zeros-in-decimal-literals.rs

@@ -0,0 +1,47 @@
+warning: this is a decimal constant
+  --> $DIR/leading-zeros-in-decimal-literals.rs:6:13
+   |
+LL |     let _ = 0111;
+   |             ^^^^
+   |
+   = note: `#[warn(leading_zeros_in_decimal_literals)]` on by default
+help: if you meant to use a decimal constant, remove leading zeros to avoid confusion
+   |
+LL -     let _ = 0111;
+LL +     let _ = 111;
+   |
+help: if you meant to use an octal constant, prefix it with `0o` instead
+   |
+LL |     let _ = 0o111;
+   |             ~~
+
+warning: this is a decimal constant
+  --> $DIR/leading-zeros-in-decimal-literals.rs:7:13
+   |
+LL |     let _ = 0007;
+   |             ^^^^
+   |
+help: if you meant to use a decimal constant, remove leading zeros to avoid confusion
+   |
+LL -     let _ = 0007;
+LL +     let _ = 7;
+   |
+help: if you meant to use an octal constant, prefix it with `0o` instead
+   |
+LL |     let _ = 0o007;
+   |             ~~
+
+warning: this is a decimal constant
+  --> $DIR/leading-zeros-in-decimal-literals.rs:8:13
+   |
+LL |     let _ = 0008;
+   |             ^^^^
+   |
+help: if you meant to use a decimal constant, remove leading zeros to avoid confusion
+   |
+LL -     let _ = 0008;
+LL +     let _ = 8;
+   |
+
+warning: 3 warnings emitted
+