//! Lints concerned with the grouping of digits with underscores in integral or
//! floating-point literal expressions.
-use crate::utils::{in_macro, snippet_opt, span_lint_and_sugg};
+use crate::utils::{
+ in_macro,
+ numeric_literal::{NumericLiteral, Radix},
+ snippet_opt, span_lint_and_sugg,
+};
use if_chain::if_chain;
-use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintContext, LintPass};
-use rustc::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
use rustc_errors::Applicability;
-use syntax::ast::*;
-use syntax_pos;
+use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
declare_clippy_lint! {
/// **What it does:** Warns if a long integral or floating-point constant does
/// **Example:**
///
/// ```rust
+ /// // Bad
/// let x: u64 = 61864918973511;
+ ///
+ /// // Good
+ /// let x: u64 = 61_864_918_973_511;
/// ```
pub UNREADABLE_LITERAL,
- style,
+ pedantic,
"long integer literal without underscores"
}
/// **Known problems:**
/// - Recommends a signed suffix, even though the number might be too big and an unsigned
/// suffix is required
- /// - Does not match on `_128` since that is a valid grouping for decimal and octal numbers
+ /// - Does not match on `_127` since that is a valid grouping for decimal and octal numbers
///
/// **Example:**
///
/// ```rust
+ /// // Probably mistyped
/// 2_32;
+ ///
+ /// // Good
+ /// 2_i32;
/// ```
pub MISTYPED_LITERAL_SUFFIXES,
correctness,
/// **Example:**
///
/// ```rust
+ /// // Bad
/// let x: u64 = 618_64_9189_73_511;
+ ///
+ /// // Good
+ /// let x: u64 = 61_864_918_973_511;
/// ```
pub INCONSISTENT_DIGIT_GROUPING,
style,
"using decimal representation when hexadecimal would be better"
}
-#[derive(Debug, PartialEq)]
-pub(super) enum Radix {
- Binary,
- Octal,
- Decimal,
- Hexadecimal,
-}
-
-impl Radix {
- /// Returns a reasonable digit group size for this radix.
- #[must_use]
- crate fn suggest_grouping(&self) -> usize {
- match *self {
- Self::Binary | Self::Hexadecimal => 4,
- Self::Octal | Self::Decimal => 3,
- }
- }
-}
-
-#[derive(Debug)]
-pub(super) struct DigitInfo<'a> {
- /// Characters of a literal between the radix prefix and type suffix.
- crate digits: &'a str,
- /// Which radix the literal was represented in.
- crate radix: Radix,
- /// The radix prefix, if present.
- crate prefix: Option<&'a str>,
- /// The type suffix, including preceding underscore if present.
- crate suffix: Option<&'a str>,
- /// True for floating-point literals.
- crate float: bool,
-}
-
-impl<'a> DigitInfo<'a> {
- #[must_use]
- crate fn new(lit: &'a str, float: bool) -> Self {
- // Determine delimiter for radix prefix, if present, and radix.
- let radix = if lit.starts_with("0x") {
- Radix::Hexadecimal
- } else if lit.starts_with("0b") {
- Radix::Binary
- } else if lit.starts_with("0o") {
- Radix::Octal
- } else {
- Radix::Decimal
- };
-
- // Grab part of the literal after prefix, if present.
- let (prefix, sans_prefix) = if let Radix::Decimal = radix {
- (None, lit)
- } else {
- let (p, s) = lit.split_at(2);
- (Some(p), s)
- };
-
- let len = sans_prefix.len();
- let mut last_d = '\0';
- for (d_idx, d) in sans_prefix.char_indices() {
- let suffix_start = if last_d == '_' { d_idx - 1 } else { d_idx };
- if float
- && (d == 'f'
- || is_possible_float_suffix_index(&sans_prefix, suffix_start, len)
- || ((d == 'E' || d == 'e') && !has_possible_float_suffix(&sans_prefix)))
- || !float && (d == 'i' || d == 'u' || is_possible_suffix_index(&sans_prefix, suffix_start, len))
- {
- let (digits, suffix) = sans_prefix.split_at(suffix_start);
- return Self {
- digits,
- radix,
- prefix,
- suffix: Some(suffix),
- float,
- };
- }
- last_d = d
- }
-
- // No suffix found
- Self {
- digits: sans_prefix,
- radix,
- prefix,
- suffix: None,
- float,
- }
- }
-
- fn split_digit_parts(&self) -> (&str, Option<&str>, Option<(char, &str)>) {
- let digits = self.digits;
-
- let mut integer = digits;
- let mut fraction = None;
- let mut exponent = None;
-
- if self.float {
- for (i, c) in digits.char_indices() {
- match c {
- '.' => {
- integer = &digits[..i];
- fraction = Some(&digits[i + 1..]);
- },
- 'e' | 'E' => {
- if integer.len() > i {
- integer = &digits[..i];
- } else {
- fraction = Some(&digits[integer.len() + 1..i]);
- };
- exponent = Some((c, &digits[i + 1..]));
- break;
- },
- _ => {},
- }
- }
- }
-
- (integer, fraction, exponent)
- }
-
- /// Returns literal formatted in a sensible way.
- crate fn grouping_hint(&self) -> String {
- let mut output = String::new();
-
- if let Some(prefix) = self.prefix {
- output.push_str(prefix);
- }
-
- let group_size = self.radix.suggest_grouping();
-
- let (integer, fraction, exponent) = &self.split_digit_parts();
-
- Self::group_digits(&mut output, integer, group_size, true, self.radix == Radix::Hexadecimal);
-
- if let Some(fraction) = fraction {
- output.push('.');
- Self::group_digits(&mut output, fraction, group_size, false, false);
- }
-
- if let Some((separator, exponent)) = exponent {
- output.push(*separator);
- Self::group_digits(&mut output, exponent, group_size, true, false);
- }
-
- if let Some(suffix) = self.suffix {
- if self.float && is_mistyped_float_suffix(suffix) {
- output.push_str("_f");
- output.push_str(&suffix[1..]);
- } else if is_mistyped_suffix(suffix) {
- output.push_str("_i");
- output.push_str(&suffix[1..]);
- } else {
- output.push_str(suffix);
- }
- }
-
- output
- }
-
- fn group_digits(output: &mut String, input: &str, group_size: usize, partial_group_first: bool, pad: bool) {
- debug_assert!(group_size > 0);
-
- let mut digits = input.chars().filter(|&c| c != '_');
-
- let first_group_size;
-
- if partial_group_first {
- first_group_size = (digits.clone().count() + group_size - 1) % group_size + 1;
- if pad {
- for _ in 0..group_size - first_group_size {
- output.push('0');
- }
- }
- } else {
- first_group_size = group_size;
- }
-
- for _ in 0..first_group_size {
- if let Some(digit) = digits.next() {
- output.push(digit);
- }
- }
-
- for (c, i) in digits.zip((0..group_size).cycle()) {
- if i == 0 {
- output.push('_');
- }
- output.push(c);
- }
- }
-}
-
enum WarningType {
UnreadableLiteral,
InconsistentDigitGrouping,
}
impl WarningType {
- crate fn display(&self, grouping_hint: &str, cx: &EarlyContext<'_>, span: syntax_pos::Span) {
+ fn display(&self, suggested_format: String, cx: &EarlyContext<'_>, span: rustc_span::Span) {
match self {
Self::MistypedLiteralSuffix => span_lint_and_sugg(
cx,
span,
"mistyped literal suffix",
"did you mean to write",
- grouping_hint.to_string(),
+ suggested_format,
Applicability::MaybeIncorrect,
),
Self::UnreadableLiteral => span_lint_and_sugg(
span,
"long literal lacking separators",
"consider",
- grouping_hint.to_owned(),
+ suggested_format,
Applicability::MachineApplicable,
),
Self::LargeDigitGroups => span_lint_and_sugg(
span,
"digit groups should be smaller",
"consider",
- grouping_hint.to_owned(),
+ suggested_format,
Applicability::MachineApplicable,
),
Self::InconsistentDigitGrouping => span_lint_and_sugg(
span,
"digits grouped inconsistently by underscores",
"consider",
- grouping_hint.to_owned(),
+ suggested_format,
Applicability::MachineApplicable,
),
Self::DecimalRepresentation => span_lint_and_sugg(
span,
"integer literal has a better hexadecimal representation",
"consider",
- grouping_hint.to_owned(),
+ suggested_format,
Applicability::MachineApplicable,
),
};
}
}
+// Length of each UUID hyphenated group in hex digits.
+const UUID_GROUP_LENS: [usize; 5] = [8, 4, 4, 4, 12];
+
impl LiteralDigitGrouping {
fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
- let in_macro = in_macro(lit.span);
-
if_chain! {
if let Some(src) = snippet_opt(cx, lit.span);
- if let Some(firstch) = src.chars().next();
- if char::is_digit(firstch, 10);
+ if let Some(mut num_lit) = NumericLiteral::from_lit(&src, &lit);
then {
+ if !Self::check_for_mistyped_suffix(cx, lit.span, &mut num_lit) {
+ return;
+ }
- let digit_info = match lit.kind {
- LitKind::Int(..) => DigitInfo::new(&src, false),
- LitKind::Float(..) => DigitInfo::new(&src, true),
- _ => return,
- };
+ if Self::is_literal_uuid_formatted(&mut num_lit) {
+ return;
+ }
let result = (|| {
- if let Some(suffix) = digit_info.suffix {
- if is_mistyped_suffix(suffix) {
- return Err(WarningType::MistypedLiteralSuffix);
- }
- }
-
- let (integer, fraction, _) = digit_info.split_digit_parts();
- let integral_group_size = Self::do_lint(integer, in_macro)?;
- if let Some(fraction) = fraction {
- let fractional_part = fraction.chars().rev().collect::<String>();
- let fractional_group_size = Self::do_lint(&fractional_part, in_macro)?;
+ let integral_group_size = Self::get_group_size(num_lit.integer.split('_'))?;
+ if let Some(fraction) = num_lit.fraction {
+ let fractional_group_size = Self::get_group_size(fraction.rsplit('_'))?;
let consistent = Self::parts_consistent(integral_group_size,
fractional_group_size,
- integer.len(),
+ num_lit.integer.len(),
fraction.len());
if !consistent {
return Err(WarningType::InconsistentDigitGrouping);
if let Err(warning_type) = result {
- warning_type.display(&digit_info.grouping_hint(), cx, lit.span)
+ let should_warn = match warning_type {
+ | WarningType::UnreadableLiteral
+ | WarningType::InconsistentDigitGrouping
+ | WarningType::LargeDigitGroups => {
+ !in_macro(lit.span)
+ }
+ WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => {
+ true
+ }
+ };
+ if should_warn {
+ warning_type.display(num_lit.format(), cx, lit.span)
+ }
}
}
}
}
+ // Returns `false` if the check fails
+ fn check_for_mistyped_suffix(
+ cx: &EarlyContext<'_>,
+ span: rustc_span::Span,
+ num_lit: &mut NumericLiteral<'_>,
+ ) -> bool {
+ if num_lit.suffix.is_some() {
+ return true;
+ }
+
+ let (part, mistyped_suffixes, missing_char) = if let Some((_, exponent)) = &mut num_lit.exponent {
+ (exponent, &["32", "64"][..], 'f')
+ } else {
+ num_lit
+ .fraction
+ .as_mut()
+ .map_or((&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i'), |fraction| {
+ (fraction, &["32", "64"][..], 'f')
+ })
+ };
+
+ let mut split = part.rsplit('_');
+ let last_group = split.next().expect("At least one group");
+ if split.next().is_some() && mistyped_suffixes.contains(&last_group) {
+ *part = &part[..part.len() - last_group.len()];
+ let mut sugg = num_lit.format();
+ sugg.push('_');
+ sugg.push(missing_char);
+ sugg.push_str(last_group);
+ WarningType::MistypedLiteralSuffix.display(sugg, cx, span);
+ false
+ } else {
+ true
+ }
+ }
+
+ /// Checks whether the numeric literal matches the formatting of a UUID.
+ ///
+ /// Returns `true` if the radix is hexadecimal, and the groups match the
+ /// UUID format of 8-4-4-4-12.
+ fn is_literal_uuid_formatted(num_lit: &mut NumericLiteral<'_>) -> bool {
+ if num_lit.radix != Radix::Hexadecimal {
+ return false;
+ }
+
+ // UUIDs should not have a fraction
+ if num_lit.fraction.is_some() {
+ return false;
+ }
+
+ let group_sizes: Vec<usize> = num_lit.integer.split('_').map(str::len).collect();
+ if UUID_GROUP_LENS.len() == group_sizes.len() {
+ UUID_GROUP_LENS.iter().zip(&group_sizes).all(|(&a, &b)| a == b)
+ } else {
+ false
+ }
+ }
+
/// Given the sizes of the digit groups of both integral and fractional
/// parts, and the length
/// of both parts, determine if the digits have been grouped consistently.
#[must_use]
- fn parts_consistent(int_group_size: usize, frac_group_size: usize, int_size: usize, frac_size: usize) -> bool {
+ fn parts_consistent(
+ int_group_size: Option<usize>,
+ frac_group_size: Option<usize>,
+ int_size: usize,
+ frac_size: usize,
+ ) -> bool {
match (int_group_size, frac_group_size) {
// No groups on either side of decimal point - trivially consistent.
- (0, 0) => true,
+ (None, None) => true,
// Integral part has grouped digits, fractional part does not.
- (_, 0) => frac_size <= int_group_size,
+ (Some(int_group_size), None) => frac_size <= int_group_size,
// Fractional part has grouped digits, integral part does not.
- (0, _) => int_size <= frac_group_size,
+ (None, Some(frac_group_size)) => int_size <= frac_group_size,
// Both parts have grouped digits. Groups should be the same size.
- (_, _) => int_group_size == frac_group_size,
+ (Some(int_group_size), Some(frac_group_size)) => int_group_size == frac_group_size,
}
}
- /// Performs lint on `digits` (no decimal point) and returns the group
- /// size on success or `WarningType` when emitting a warning.
- fn do_lint(digits: &str, in_macro: bool) -> Result<usize, WarningType> {
- // Grab underscore indices with respect to the units digit.
- let underscore_positions: Vec<usize> = digits
- .chars()
- .rev()
- .enumerate()
- .filter_map(|(idx, digit)| if digit == '_' { Some(idx) } else { None })
- .collect();
-
- if underscore_positions.is_empty() {
- // Check if literal needs underscores.
- if !in_macro && digits.len() > 5 {
- Err(WarningType::UnreadableLiteral)
+ /// Returns the size of the digit groups (or None if ungrouped) if successful,
+ /// otherwise returns a `WarningType` for linting.
+ fn get_group_size<'a>(groups: impl Iterator<Item = &'a str>) -> Result<Option<usize>, WarningType> {
+ let mut groups = groups.map(str::len);
+
+ let first = groups.next().expect("At least one group");
+
+ if let Some(second) = groups.next() {
+ if !groups.all(|x| x == second) || first > second {
+ Err(WarningType::InconsistentDigitGrouping)
+ } else if second > 4 {
+ Err(WarningType::LargeDigitGroups)
} else {
- Ok(0)
+ Ok(Some(second))
}
+ } else if first > 5 {
+ Err(WarningType::UnreadableLiteral)
} else {
- // Check consistency and the sizes of the groups.
- let group_size = underscore_positions[0];
- let consistent = underscore_positions
- .windows(2)
- .all(|ps| ps[1] - ps[0] == group_size + 1)
- // number of digits to the left of the last group cannot be bigger than group size.
- && (digits.len() - underscore_positions.last()
- .expect("there's at least one element") <= group_size + 1);
-
- if !consistent {
- return Err(WarningType::InconsistentDigitGrouping);
- } else if group_size > 4 {
- return Err(WarningType::LargeDigitGroups);
- }
- Ok(group_size)
+ Ok(None)
}
}
}
if_chain! {
if let LitKind::Int(val, _) = lit.kind;
if let Some(src) = snippet_opt(cx, lit.span);
- if let Some(firstch) = src.chars().next();
- if char::is_digit(firstch, 10);
- let digit_info = DigitInfo::new(&src, false);
- if digit_info.radix == Radix::Decimal;
+ if let Some(num_lit) = NumericLiteral::from_lit(&src, &lit);
+ if num_lit.radix == Radix::Decimal;
if val >= u128::from(self.threshold);
then {
let hex = format!("{:#X}", val);
- let digit_info = DigitInfo::new(&hex, false);
- let _ = Self::do_lint(digit_info.digits).map_err(|warning_type| {
- warning_type.display(&digit_info.grouping_hint(), cx, lit.span)
+ let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
+ let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
+ warning_type.display(num_lit.format(), cx, lit.span)
});
}
}
Ok(())
}
}
-
-#[must_use]
-fn is_mistyped_suffix(suffix: &str) -> bool {
- ["_8", "_16", "_32", "_64"].contains(&suffix)
-}
-
-#[must_use]
-fn is_possible_suffix_index(lit: &str, idx: usize, len: usize) -> bool {
- ((len > 3 && idx == len - 3) || (len > 2 && idx == len - 2)) && is_mistyped_suffix(lit.split_at(idx).1)
-}
-
-#[must_use]
-fn is_mistyped_float_suffix(suffix: &str) -> bool {
- ["_32", "_64"].contains(&suffix)
-}
-
-#[must_use]
-fn is_possible_float_suffix_index(lit: &str, idx: usize, len: usize) -> bool {
- (len > 3 && idx == len - 3) && is_mistyped_float_suffix(lit.split_at(idx).1)
-}
-
-#[must_use]
-fn has_possible_float_suffix(lit: &str) -> bool {
- lit.ends_with("_32") || lit.ends_with("_64")
-}
projects / rust.git / blobdiff