Skip to content

Commit cbd6159

Browse files
borsbors
committedNov 16, 2022
Auto merge of rust-lang#102944 - nnethercote:ast-Lit-third-time-lucky, r=petrochenkov
Use `token::Lit` in `ast::ExprKind::Lit`. Instead of `ast::Lit`. Literal lowering now happens at two different times. Expression literals are lowered when HIR is crated. Attribute literals are lowered during parsing. r? `@petrochenkov`
2 parents 2bf87f3 + f2d83ed commit cbd6159

12 files changed

+90
-77
lines changed
 

‎clippy_lints/src/almost_complete_letter_range.rs

+14-5
Original file line numberDiff line numberDiff line change
@@ -73,12 +73,21 @@ impl EarlyLintPass for AlmostCompleteLetterRange {
7373
}
7474

7575
fn check_range(cx: &EarlyContext<'_>, span: Span, start: &Expr, end: &Expr, sugg: Option<(Span, &str)>) {
76-
if let ExprKind::Lit(start_lit) = &start.peel_parens().kind
77-
&& let ExprKind::Lit(end_lit) = &end.peel_parens().kind
76+
if let ExprKind::Lit(start_token_lit) = start.peel_parens().kind
77+
&& let ExprKind::Lit(end_token_lit) = end.peel_parens().kind
7878
&& matches!(
79-
(&start_lit.kind, &end_lit.kind),
80-
(LitKind::Byte(b'a') | LitKind::Char('a'), LitKind::Byte(b'z') | LitKind::Char('z'))
81-
| (LitKind::Byte(b'A') | LitKind::Char('A'), LitKind::Byte(b'Z') | LitKind::Char('Z'))
79+
(
80+
LitKind::from_token_lit(start_token_lit),
81+
LitKind::from_token_lit(end_token_lit),
82+
),
83+
(
84+
Ok(LitKind::Byte(b'a') | LitKind::Char('a')),
85+
Ok(LitKind::Byte(b'z') | LitKind::Char('z'))
86+
)
87+
| (
88+
Ok(LitKind::Byte(b'A') | LitKind::Char('A')),
89+
Ok(LitKind::Byte(b'Z') | LitKind::Char('Z')),
90+
)
8291
)
8392
&& !in_external_macro(cx.sess(), span)
8493
{

‎clippy_lints/src/int_plus_one.rs

+12-11
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,8 @@
22
33
use clippy_utils::diagnostics::span_lint_and_sugg;
44
use clippy_utils::source::snippet_opt;
5-
use rustc_ast::ast::{BinOpKind, Expr, ExprKind, Lit, LitKind};
5+
use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind};
6+
use rustc_ast::token;
67
use rustc_errors::Applicability;
78
use rustc_lint::{EarlyContext, EarlyLintPass};
89
use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -52,8 +53,8 @@ enum Side {
5253

5354
impl IntPlusOne {
5455
#[expect(clippy::cast_sign_loss)]
55-
fn check_lit(lit: &Lit, target_value: i128) -> bool {
56-
if let LitKind::Int(value, ..) = lit.kind {
56+
fn check_lit(token_lit: token::Lit, target_value: i128) -> bool {
57+
if let Ok(LitKind::Int(value, ..)) = LitKind::from_token_lit(token_lit) {
5758
return value == (target_value as u128);
5859
}
5960
false
@@ -65,11 +66,11 @@ impl IntPlusOne {
6566
(BinOpKind::Ge, &ExprKind::Binary(ref lhskind, ref lhslhs, ref lhsrhs), _) => {
6667
match (lhskind.node, &lhslhs.kind, &lhsrhs.kind) {
6768
// `-1 + x`
68-
(BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
69+
(BinOpKind::Add, &ExprKind::Lit(lit), _) if Self::check_lit(lit, -1) => {
6970
Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
7071
},
7172
// `x - 1`
72-
(BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
73+
(BinOpKind::Sub, _, &ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
7374
Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
7475
},
7576
_ => None,
@@ -81,10 +82,10 @@ impl IntPlusOne {
8182
{
8283
match (&rhslhs.kind, &rhsrhs.kind) {
8384
// `y + 1` and `1 + y`
84-
(&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
85+
(&ExprKind::Lit(lit), _) if Self::check_lit(lit, 1) => {
8586
Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
8687
},
87-
(_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
88+
(_, &ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
8889
Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
8990
},
9091
_ => None,
@@ -96,10 +97,10 @@ impl IntPlusOne {
9697
{
9798
match (&lhslhs.kind, &lhsrhs.kind) {
9899
// `1 + x` and `x + 1`
99-
(&ExprKind::Lit(ref lit), _) if Self::check_lit(lit, 1) => {
100+
(&ExprKind::Lit(lit), _) if Self::check_lit(lit, 1) => {
100101
Self::generate_recommendation(cx, binop, lhsrhs, rhs, Side::Lhs)
101102
},
102-
(_, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
103+
(_, &ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
103104
Self::generate_recommendation(cx, binop, lhslhs, rhs, Side::Lhs)
104105
},
105106
_ => None,
@@ -109,11 +110,11 @@ impl IntPlusOne {
109110
(BinOpKind::Le, _, &ExprKind::Binary(ref rhskind, ref rhslhs, ref rhsrhs)) => {
110111
match (rhskind.node, &rhslhs.kind, &rhsrhs.kind) {
111112
// `-1 + y`
112-
(BinOpKind::Add, &ExprKind::Lit(ref lit), _) if Self::check_lit(lit, -1) => {
113+
(BinOpKind::Add, &ExprKind::Lit(lit), _) if Self::check_lit(lit, -1) => {
113114
Self::generate_recommendation(cx, binop, rhsrhs, lhs, Side::Rhs)
114115
},
115116
// `y - 1`
116-
(BinOpKind::Sub, _, &ExprKind::Lit(ref lit)) if Self::check_lit(lit, 1) => {
117+
(BinOpKind::Sub, _, &ExprKind::Lit(lit)) if Self::check_lit(lit, 1) => {
117118
Self::generate_recommendation(cx, binop, rhslhs, lhs, Side::Rhs)
118119
},
119120
_ => None,

‎clippy_lints/src/literal_representation.rs

+20-16
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,13 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
55
use clippy_utils::numeric_literal::{NumericLiteral, Radix};
66
use clippy_utils::source::snippet_opt;
77
use if_chain::if_chain;
8-
use rustc_ast::ast::{Expr, ExprKind, Lit, LitKind};
8+
use rustc_ast::ast::{Expr, ExprKind, LitKind};
9+
use rustc_ast::token;
910
use rustc_errors::Applicability;
1011
use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
1112
use rustc_middle::lint::in_external_macro;
1213
use rustc_session::{declare_tool_lint, impl_lint_pass};
14+
use rustc_span::Span;
1315
use std::iter;
1416

1517
declare_clippy_lint! {
@@ -236,8 +238,8 @@ impl EarlyLintPass for LiteralDigitGrouping {
236238
return;
237239
}
238240

239-
if let ExprKind::Lit(ref lit) = expr.kind {
240-
self.check_lit(cx, lit);
241+
if let ExprKind::Lit(lit) = expr.kind {
242+
self.check_lit(cx, lit, expr.span);
241243
}
242244
}
243245
}
@@ -252,12 +254,13 @@ impl LiteralDigitGrouping {
252254
}
253255
}
254256

255-
fn check_lit(self, cx: &EarlyContext<'_>, lit: &Lit) {
257+
fn check_lit(self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
256258
if_chain! {
257-
if let Some(src) = snippet_opt(cx, lit.span);
258-
if let Some(mut num_lit) = NumericLiteral::from_lit(&src, lit);
259+
if let Some(src) = snippet_opt(cx, span);
260+
if let Ok(lit_kind) = LitKind::from_token_lit(lit);
261+
if let Some(mut num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind);
259262
then {
260-
if !Self::check_for_mistyped_suffix(cx, lit.span, &mut num_lit) {
263+
if !Self::check_for_mistyped_suffix(cx, span, &mut num_lit) {
261264
return;
262265
}
263266

@@ -293,14 +296,14 @@ impl LiteralDigitGrouping {
293296
| WarningType::InconsistentDigitGrouping
294297
| WarningType::UnusualByteGroupings
295298
| WarningType::LargeDigitGroups => {
296-
!lit.span.from_expansion()
299+
!span.from_expansion()
297300
}
298301
WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => {
299302
true
300303
}
301304
};
302305
if should_warn {
303-
warning_type.display(num_lit.format(), cx, lit.span);
306+
warning_type.display(num_lit.format(), cx, span);
304307
}
305308
}
306309
}
@@ -458,8 +461,8 @@ impl EarlyLintPass for DecimalLiteralRepresentation {
458461
return;
459462
}
460463

461-
if let ExprKind::Lit(ref lit) = expr.kind {
462-
self.check_lit(cx, lit);
464+
if let ExprKind::Lit(lit) = expr.kind {
465+
self.check_lit(cx, lit, expr.span);
463466
}
464467
}
465468
}
@@ -469,19 +472,20 @@ impl DecimalLiteralRepresentation {
469472
pub fn new(threshold: u64) -> Self {
470473
Self { threshold }
471474
}
472-
fn check_lit(self, cx: &EarlyContext<'_>, lit: &Lit) {
475+
fn check_lit(self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
473476
// Lint integral literals.
474477
if_chain! {
475-
if let LitKind::Int(val, _) = lit.kind;
476-
if let Some(src) = snippet_opt(cx, lit.span);
477-
if let Some(num_lit) = NumericLiteral::from_lit(&src, lit);
478+
if let Ok(lit_kind) = LitKind::from_token_lit(lit);
479+
if let LitKind::Int(val, _) = lit_kind;
480+
if let Some(src) = snippet_opt(cx, span);
481+
if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind);
478482
if num_lit.radix == Radix::Decimal;
479483
if val >= u128::from(self.threshold);
480484
then {
481485
let hex = format!("{val:#X}");
482486
let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
483487
let _ = Self::do_lint(num_lit.integer).map_err(|warning_type| {
484-
warning_type.display(num_lit.format(), cx, lit.span);
488+
warning_type.display(num_lit.format(), cx, span);
485489
});
486490
}
487491
}

‎clippy_lints/src/misc_early/literal_suffix.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
use clippy_utils::diagnostics::span_lint_and_sugg;
2-
use rustc_ast::ast::Lit;
32
use rustc_errors::Applicability;
43
use rustc_lint::EarlyContext;
4+
use rustc_span::Span;
55

66
use super::{SEPARATED_LITERAL_SUFFIX, UNSEPARATED_LITERAL_SUFFIX};
77

8-
pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &str, sugg_type: &str) {
8+
pub(super) fn check(cx: &EarlyContext<'_>, lit_span: Span, lit_snip: &str, suffix: &str, sugg_type: &str) {
99
let Some(maybe_last_sep_idx) = lit_snip.len().checked_sub(suffix.len() + 1) else {
1010
return; // It's useless so shouldn't lint.
1111
};
@@ -15,7 +15,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &s
1515
span_lint_and_sugg(
1616
cx,
1717
SEPARATED_LITERAL_SUFFIX,
18-
lit.span,
18+
lit_span,
1919
&format!("{sugg_type} type suffix should not be separated by an underscore"),
2020
"remove the underscore",
2121
format!("{}{suffix}", &lit_snip[..maybe_last_sep_idx]),
@@ -25,7 +25,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str, suffix: &s
2525
span_lint_and_sugg(
2626
cx,
2727
UNSEPARATED_LITERAL_SUFFIX,
28-
lit.span,
28+
lit_span,
2929
&format!("{sugg_type} type suffix should be separated by an underscore"),
3030
"add an underscore",
3131
format!("{}_{suffix}", &lit_snip[..=maybe_last_sep_idx]),

‎clippy_lints/src/misc_early/mixed_case_hex_literals.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11
use clippy_utils::diagnostics::span_lint;
2-
use rustc_ast::ast::Lit;
32
use rustc_lint::EarlyContext;
3+
use rustc_span::Span;
44

55
use super::MIXED_CASE_HEX_LITERALS;
66

7-
pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, suffix: &str, lit_snip: &str) {
7+
pub(super) fn check(cx: &EarlyContext<'_>, lit_span: Span, suffix: &str, lit_snip: &str) {
88
let Some(maybe_last_sep_idx) = lit_snip.len().checked_sub(suffix.len() + 1) else {
99
return; // It's useless so shouldn't lint.
1010
};
@@ -23,7 +23,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, suffix: &str, lit_snip: &s
2323
span_lint(
2424
cx,
2525
MIXED_CASE_HEX_LITERALS,
26-
lit.span,
26+
lit_span,
2727
"inconsistent casing in hexadecimal literal",
2828
);
2929
break;

‎clippy_lints/src/misc_early/mod.rs

+13-11
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,8 @@ mod zero_prefixed_literal;
99

1010
use clippy_utils::diagnostics::span_lint;
1111
use clippy_utils::source::snippet_opt;
12-
use rustc_ast::ast::{Expr, ExprKind, Generics, Lit, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
12+
use rustc_ast::ast::{Expr, ExprKind, Generics, LitFloatType, LitIntType, LitKind, NodeId, Pat, PatKind};
13+
use rustc_ast::token;
1314
use rustc_ast::visit::FnKind;
1415
use rustc_data_structures::fx::FxHashMap;
1516
use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
@@ -374,42 +375,43 @@ impl EarlyLintPass for MiscEarlyLints {
374375
return;
375376
}
376377

377-
if let ExprKind::Lit(ref lit) = expr.kind {
378-
MiscEarlyLints::check_lit(cx, lit);
378+
if let ExprKind::Lit(lit) = expr.kind {
379+
MiscEarlyLints::check_lit(cx, lit, expr.span);
379380
}
380381
double_neg::check(cx, expr);
381382
}
382383
}
383384

384385
impl MiscEarlyLints {
385-
fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
386+
fn check_lit(cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
386387
// We test if first character in snippet is a number, because the snippet could be an expansion
387388
// from a built-in macro like `line!()` or a proc-macro like `#[wasm_bindgen]`.
388389
// Note that this check also covers special case that `line!()` is eagerly expanded by compiler.
389390
// See <https://github.com/rust-lang/rust-clippy/issues/4507> for a regression.
390391
// FIXME: Find a better way to detect those cases.
391-
let lit_snip = match snippet_opt(cx, lit.span) {
392+
let lit_snip = match snippet_opt(cx, span) {
392393
Some(snip) if snip.chars().next().map_or(false, |c| c.is_ascii_digit()) => snip,
393394
_ => return,
394395
};
395396

396-
if let LitKind::Int(value, lit_int_type) = lit.kind {
397+
let lit_kind = LitKind::from_token_lit(lit);
398+
if let Ok(LitKind::Int(value, lit_int_type)) = lit_kind {
397399
let suffix = match lit_int_type {
398400
LitIntType::Signed(ty) => ty.name_str(),
399401
LitIntType::Unsigned(ty) => ty.name_str(),
400402
LitIntType::Unsuffixed => "",
401403
};
402-
literal_suffix::check(cx, lit, &lit_snip, suffix, "integer");
404+
literal_suffix::check(cx, span, &lit_snip, suffix, "integer");
403405
if lit_snip.starts_with("0x") {
404-
mixed_case_hex_literals::check(cx, lit, suffix, &lit_snip);
406+
mixed_case_hex_literals::check(cx, span, suffix, &lit_snip);
405407
} else if lit_snip.starts_with("0b") || lit_snip.starts_with("0o") {
406408
// nothing to do
407409
} else if value != 0 && lit_snip.starts_with('0') {
408-
zero_prefixed_literal::check(cx, lit, &lit_snip);
410+
zero_prefixed_literal::check(cx, span, &lit_snip);
409411
}
410-
} else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
412+
} else if let Ok(LitKind::Float(_, LitFloatType::Suffixed(float_ty))) = lit_kind {
411413
let suffix = float_ty.name_str();
412-
literal_suffix::check(cx, lit, &lit_snip, suffix, "float");
414+
literal_suffix::check(cx, span, &lit_snip, suffix, "float");
413415
}
414416
}
415417
}

‎clippy_lints/src/misc_early/zero_prefixed_literal.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,28 +1,28 @@
11
use clippy_utils::diagnostics::span_lint_and_then;
2-
use rustc_ast::ast::Lit;
32
use rustc_errors::Applicability;
43
use rustc_lint::EarlyContext;
4+
use rustc_span::Span;
55

66
use super::ZERO_PREFIXED_LITERAL;
77

8-
pub(super) fn check(cx: &EarlyContext<'_>, lit: &Lit, lit_snip: &str) {
8+
pub(super) fn check(cx: &EarlyContext<'_>, lit_span: Span, lit_snip: &str) {
99
let trimmed_lit_snip = lit_snip.trim_start_matches(|c| c == '_' || c == '0');
1010
span_lint_and_then(
1111
cx,
1212
ZERO_PREFIXED_LITERAL,
13-
lit.span,
13+
lit_span,
1414
"this is a decimal constant",
1515
|diag| {
1616
diag.span_suggestion(
17-
lit.span,
17+
lit_span,
1818
"if you mean to use a decimal constant, remove the `0` to avoid confusion",
1919
trimmed_lit_snip.to_string(),
2020
Applicability::MaybeIncorrect,
2121
);
2222
// do not advise to use octal form if the literal cannot be expressed in base 8.
2323
if !lit_snip.contains(|c| c == '8' || c == '9') {
2424
diag.span_suggestion(
25-
lit.span,
25+
lit_span,
2626
"if you mean to use an octal constant, use `0o`",
2727
format!("0o{trimmed_lit_snip}"),
2828
Applicability::MaybeIncorrect,

‎clippy_lints/src/octal_escapes.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -56,11 +56,11 @@ impl EarlyLintPass for OctalEscapes {
5656
return;
5757
}
5858

59-
if let ExprKind::Lit(lit) = &expr.kind {
60-
if matches!(lit.token_lit.kind, LitKind::Str) {
61-
check_lit(cx, &lit.token_lit, lit.span, true);
62-
} else if matches!(lit.token_lit.kind, LitKind::ByteStr) {
63-
check_lit(cx, &lit.token_lit, lit.span, false);
59+
if let ExprKind::Lit(token_lit) = &expr.kind {
60+
if matches!(token_lit.kind, LitKind::Str) {
61+
check_lit(cx, &token_lit, expr.span, true);
62+
} else if matches!(token_lit.kind, LitKind::ByteStr) {
63+
check_lit(cx, &token_lit, expr.span, false);
6464
}
6565
}
6666
}

‎clippy_lints/src/precedence.rs

+3-2
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
use clippy_utils::diagnostics::span_lint_and_sugg;
22
use clippy_utils::source::snippet_with_applicability;
33
use if_chain::if_chain;
4-
use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind, UnOp};
4+
use rustc_ast::ast::{BinOpKind, Expr, ExprKind, UnOp};
5+
use rustc_ast::token;
56
use rustc_errors::Applicability;
67
use rustc_lint::{EarlyContext, EarlyLintPass};
78
use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -120,7 +121,7 @@ impl EarlyLintPass for Precedence {
120121
if_chain! {
121122
if !all_odd;
122123
if let ExprKind::Lit(lit) = &arg.kind;
123-
if let LitKind::Int(..) | LitKind::Float(..) = &lit.kind;
124+
if let token::LitKind::Integer | token::LitKind::Float = &lit.kind;
124125
then {
125126
let mut applicability = Applicability::MachineApplicable;
126127
span_lint_and_sugg(

‎clippy_lints/src/unused_rounding.rs

+9-9
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use clippy_utils::diagnostics::span_lint_and_sugg;
2-
use rustc_ast::ast::{Expr, ExprKind, LitFloatType, LitKind};
2+
use rustc_ast::ast::{Expr, ExprKind};
33
use rustc_errors::Applicability;
44
use rustc_lint::{EarlyContext, EarlyLintPass};
55
use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -33,14 +33,14 @@ fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
3333
if let ExprKind::MethodCall(name_ident, receiver, _, _) = &expr.kind
3434
&& let method_name = name_ident.ident.name.as_str()
3535
&& (method_name == "ceil" || method_name == "round" || method_name == "floor")
36-
&& let ExprKind::Lit(spanned) = &receiver.kind
37-
&& let LitKind::Float(symbol, ty) = spanned.kind {
38-
let f = symbol.as_str().parse::<f64>().unwrap();
39-
let f_str = symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {
40-
ty.name_str()
41-
} else {
42-
""
43-
};
36+
&& let ExprKind::Lit(token_lit) = &receiver.kind
37+
&& token_lit.is_semantic_float() {
38+
let f = token_lit.symbol.as_str().parse::<f64>().unwrap();
39+
let mut f_str = token_lit.symbol.to_string();
40+
match token_lit.suffix {
41+
Some(suffix) => f_str.push_str(suffix.as_str()),
42+
None => {}
43+
}
4444
if f.fract() == 0.0 {
4545
Some((method_name, f_str))
4646
} else {

‎clippy_utils/src/ast_utils.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
152152
},
153153
(Binary(lo, ll, lr), Binary(ro, rl, rr)) => lo.node == ro.node && eq_expr(ll, rl) && eq_expr(lr, rr),
154154
(Unary(lo, l), Unary(ro, r)) => mem::discriminant(lo) == mem::discriminant(ro) && eq_expr(l, r),
155-
(Lit(l), Lit(r)) => l.kind == r.kind,
155+
(Lit(l), Lit(r)) => l == r,
156156
(Cast(l, lt), Cast(r, rt)) | (Type(l, lt), Type(r, rt)) => eq_expr(l, r) && eq_ty(lt, rt),
157157
(Let(lp, le, _), Let(rp, re, _)) => eq_pat(lp, rp) && eq_expr(le, re),
158158
(If(lc, lt, le), If(rc, rt, re)) => eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le, re),

‎clippy_utils/src/numeric_literal.rs

+1-5
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use rustc_ast::ast::{Lit, LitFloatType, LitIntType, LitKind};
1+
use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
22
use std::iter;
33

44
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
@@ -46,10 +46,6 @@ pub struct NumericLiteral<'a> {
4646
}
4747

4848
impl<'a> NumericLiteral<'a> {
49-
pub fn from_lit(src: &'a str, lit: &Lit) -> Option<NumericLiteral<'a>> {
50-
NumericLiteral::from_lit_kind(src, &lit.kind)
51-
}
52-
5349
pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
5450
let unsigned_src = src.strip_prefix('-').map_or(src, |s| s);
5551
if lit_kind.is_numeric()

0 commit comments

Comments
 (0)
Please sign in to comment.