@@ -26,6 +26,26 @@ declare_clippy_lint! {
2626 "long integer literal without underscores"
2727}
2828
29+ /// **What it does:** Warns for mistyped suffix in literals
30+ ///
31+ /// **Why is this bad?** This is most probably a typo
32+ ///
33+ /// **Known problems:**
34+ /// - Recommends a signed suffix, even though the number might be too big and an unsigned
35+ /// suffix is required
36+ /// - Does not match on `_128` since that is a valid grouping for decimal and octal numbers
37+ ///
38+ /// **Example:**
39+ ///
40+ /// ```rust
41+ /// 2_32
42+ /// ```
43+ declare_clippy_lint ! {
44+ pub MISTYPED_LITERAL_SUFFIXES ,
45+ correctness,
46+ "mistyped literal suffix"
47+ }
48+
2949/// **What it does:** Warns if an integral or floating-point constant is
3050/// grouped inconsistently with underscores.
3151///
@@ -135,18 +155,24 @@ impl<'a> DigitInfo<'a> {
135155 ( Some ( p) , s)
136156 } ;
137157
158+ let len = sans_prefix. len ( ) ;
138159 let mut last_d = '\0' ;
139160 for ( d_idx, d) in sans_prefix. char_indices ( ) {
140- if !float && ( d == 'i' || d == 'u' ) || float && ( d == 'f' || d == 'e' || d == 'E' ) {
141- let suffix_start = if last_d == '_' { d_idx - 1 } else { d_idx } ;
142- let ( digits, suffix) = sans_prefix. split_at ( suffix_start) ;
143- return Self {
144- digits,
145- radix,
146- prefix,
147- suffix : Some ( suffix) ,
148- float,
149- } ;
161+ let suffix_start = if last_d == '_' {
162+ d_idx - 1
163+ } else {
164+ d_idx
165+ } ;
166+ if float && ( d == 'f' || d == 'e' || d == 'E' ) ||
167+ !float && ( d == 'i' || d == 'u' || is_possible_suffix_index ( & sans_prefix, suffix_start, len) ) {
168+ let ( digits, suffix) = sans_prefix. split_at ( suffix_start) ;
169+ return Self {
170+ digits,
171+ radix,
172+ prefix,
173+ suffix : Some ( suffix) ,
174+ float,
175+ } ;
150176 }
151177 last_d = d
152178 }
@@ -161,7 +187,7 @@ impl<'a> DigitInfo<'a> {
161187 }
162188 }
163189
164- /// Returns digits grouped in a sensible way.
190+ /// Returns literal formatted in a sensible way.
165191crate fn grouping_hint ( & self ) -> String {
166192 let group_size = self . radix . suggest_grouping ( ) ;
167193 if self . digits . contains ( '.' ) {
@@ -211,11 +237,18 @@ impl<'a> DigitInfo<'a> {
211237 if self . radix == Radix :: Hexadecimal && nb_digits_to_fill != 0 {
212238 hint = format ! ( "{:0>4}{}" , & hint[ ..nb_digits_to_fill] , & hint[ nb_digits_to_fill..] ) ;
213239 }
240+ let suffix_hint = match self . suffix {
241+ Some ( suffix) if is_mistyped_suffix ( suffix) => {
242+ format ! ( "_i{}" , & suffix[ 1 ..] )
243+ } ,
244+ Some ( suffix) => suffix. to_string ( ) ,
245+ None => String :: new ( )
246+ } ;
214247 format ! (
215248 "{}{}{}" ,
216249 self . prefix. unwrap_or( "" ) ,
217250 hint,
218- self . suffix . unwrap_or ( "" )
251+ suffix_hint
219252 )
220253 }
221254 }
@@ -226,11 +259,22 @@ enum WarningType {
226259 InconsistentDigitGrouping ,
227260 LargeDigitGroups ,
228261 DecimalRepresentation ,
262+ MistypedLiteralSuffix
229263}
230264
231265impl WarningType {
232266 crate fn display ( & self , grouping_hint : & str , cx : & EarlyContext < ' _ > , span : syntax_pos:: Span ) {
233267 match self {
268+ WarningType :: MistypedLiteralSuffix => {
269+ span_lint_and_sugg (
270+ cx,
271+ MISTYPED_LITERAL_SUFFIXES ,
272+ span,
273+ "mistyped literal suffix" ,
274+ "did you mean to write" ,
275+ grouping_hint. to_string ( )
276+ )
277+ } ,
234278 WarningType :: UnreadableLiteral => span_lint_and_sugg (
235279 cx,
236280 UNREADABLE_LITERAL ,
@@ -303,7 +347,7 @@ impl LiteralDigitGrouping {
303347 if char :: to_digit( firstch, 10 ) . is_some( ) ;
304348 then {
305349 let digit_info = DigitInfo :: new( & src, false ) ;
306- let _ = Self :: do_lint( digit_info. digits) . map_err( |warning_type| {
350+ let _ = Self :: do_lint( digit_info. digits, digit_info . suffix ) . map_err( |warning_type| {
307351 warning_type. display( & digit_info. grouping_hint( ) , cx, lit. span)
308352 } ) ;
309353 }
@@ -325,12 +369,12 @@ impl LiteralDigitGrouping {
325369
326370 // Lint integral and fractional parts separately, and then check consistency of digit
327371 // groups if both pass.
328- let _ = Self :: do_lint( parts[ 0 ] )
372+ let _ = Self :: do_lint( parts[ 0 ] , None )
329373 . map( |integral_group_size| {
330374 if parts. len( ) > 1 {
331375 // Lint the fractional part of literal just like integral part, but reversed.
332376 let fractional_part = & parts[ 1 ] . chars( ) . rev( ) . collect:: <String >( ) ;
333- let _ = Self :: do_lint( fractional_part)
377+ let _ = Self :: do_lint( fractional_part, None )
334378 . map( |fractional_group_size| {
335379 let consistent = Self :: parts_consistent( integral_group_size,
336380 fractional_group_size,
@@ -373,7 +417,12 @@ impl LiteralDigitGrouping {
373417
374418 /// Performs lint on `digits` (no decimal point) and returns the group
375419/// size on success or `WarningType` when emitting a warning.
376- fn do_lint ( digits : & str ) -> Result < usize , WarningType > {
420+ fn do_lint ( digits : & str , suffix : Option < & str > ) -> Result < usize , WarningType > {
421+ if let Some ( suffix) = suffix {
422+ if is_mistyped_suffix ( suffix) {
423+ return Err ( WarningType :: MistypedLiteralSuffix ) ;
424+ }
425+ }
377426 // Grab underscore indices with respect to the units digit.
378427 let underscore_positions: Vec < usize > = digits
379428 . chars ( )
@@ -504,3 +553,12 @@ impl LiteralRepresentation {
504553 Ok ( ( ) )
505554 }
506555}
556+
557+ fn is_mistyped_suffix ( suffix : & str ) -> bool {
558+ [ "_8" , "_16" , "_32" , "_64" ] . contains ( & suffix)
559+ }
560+
561+ fn is_possible_suffix_index ( lit : & str , idx : usize , len : usize ) -> bool {
562+ ( ( len > 3 && idx == len - 3 ) || ( len > 2 && idx == len - 2 ) ) &&
563+ is_mistyped_suffix ( lit. split_at ( idx) . 1 )
564+ }
0 commit comments