mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rustup to rust-lang/rust#65884

Browse Source
This commit is contained in:
flip1995 2019-11-07 13:27:00 +01:00
parent 305ba73fc1
commit e917b01286
No known key found for this signature in database
GPG Key ID: 693086869D506637
9 changed files with 30 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
clippy_lints/src/approx_const.rs
View File

@ -3,7 +3,7 @@
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
use rustc::{declare_lint_pass, declare_tool_lint};
use std::f64::consts as f64;
use syntax::ast::{FloatTy, LitKind};
use syntax::ast::{FloatTy, LitFloatType, LitKind};
use syntax::symbol;
declare_clippy_lint! {
@ -62,9 +62,11 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) {
match *lit {
LitKind::Float(s, FloatTy::F32) => check_known_consts(cx, e, s, "f32"),
LitKind::Float(s, FloatTy::F64) => check_known_consts(cx, e, s, "f64"),
LitKind::FloatUnsuffixed(s) => check_known_consts(cx, e, s, "f{32, 64}"),
LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
FloatTy::F32 => check_known_consts(cx, e, s, "f32"),
FloatTy::F64 => check_known_consts(cx, e, s, "f64"),
},
LitKind::Float(s, LitFloatType::Unsuffixed) => check_known_consts(cx, e, s, "f{32, 64}"),
_ => (),
}
}

8
clippy_lints/src/consts.rs
View File

@ -161,9 +161,11 @@ pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
LitKind::ByteStr(ref s) => Constant::Binary(Lrc::clone(s)),
LitKind::Char(c) => Constant::Char(c),
LitKind::Int(n, _) => Constant::Int(n),
LitKind::Float(ref is, FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
LitKind::Float(ref is, FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
LitKind::FloatUnsuffixed(ref is) => match ty.expect("type of float is known").kind {
LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
},
LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind {
ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
_ => bug!(),

2
clippy_lints/src/excessive_precision.rs
View File

@ -43,7 +43,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
let ty = cx.tables.expr_ty(expr);
if let ty::Float(fty) = ty.kind;
if let hir::ExprKind::Lit(ref lit) = expr.kind;
if let LitKind::Float(sym, _) | LitKind::FloatUnsuffixed(sym) = lit.node;
if let LitKind::Float(sym, _) = lit.node;
if let Some(sugg) = Self::check(sym, fty);
then {
span_lint_and_sugg(

2
clippy_lints/src/literal_representation.rs
View File

@ -373,7 +373,7 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
}
}
},
LitKind::Float(..) | LitKind::FloatUnsuffixed(..) => {
LitKind::Float(..) => {
// Lint floating-point literals.
if_chain! {
if let Some(src) = snippet_opt(cx, lit.span);

8
clippy_lints/src/misc_early.rs
View File

@ -482,8 +482,8 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
if let LitKind::Int(value, lit_int_type) = lit.kind {
let suffix = match lit_int_type {
LitIntType::Signed(ty) => ty.ty_to_string(),
LitIntType::Unsigned(ty) => ty.ty_to_string(),
LitIntType::Signed(ty) => ty.name_str(),
LitIntType::Unsigned(ty) => ty.name_str(),
LitIntType::Unsuffixed => "",
};
@ -543,8 +543,8 @@ fn check_lit(cx: &EarlyContext<'_>, lit: &Lit) {
},
);
}
} else if let LitKind::Float(_, float_ty) = lit.kind {
let suffix = float_ty.ty_to_string();
} else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
let suffix = float_ty.name_str();
let maybe_last_sep_idx = lit_snip.len() - suffix.len() - 1;
if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
span_lint_and_sugg(

2
clippy_lints/src/precedence.rs
View File

@ -90,7 +90,7 @@ fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
if let Some(slf) = args.first() {
if let ExprKind::Lit(ref lit) = slf.kind {
match lit.kind {
LitKind::Int(..) | LitKind::Float(..) | LitKind::FloatUnsuffixed(..) => {
LitKind::Int(..) | LitKind::Float(..) => {
let mut applicability = Applicability::MachineApplicable;
span_lint_and_sugg(
cx,

2
clippy_lints/src/transmute.rs
View File

@ -390,7 +390,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
|db| {
let arg = sugg::Sugg::hir(cx, &args[0], "..");
let arg = if let ty::Int(_) = from_ty.kind {
arg.as_ty(ast::UintTy::U32)
arg.as_ty(ast::UintTy::U32.name_str())
} else {
arg
};

4
clippy_lints/src/types.rs
View File

@ -15,7 +15,7 @@
use rustc_errors::Applicability;
use rustc_target::spec::abi::Abi;
use rustc_typeck::hir_ty_to_ty;
use syntax::ast::{FloatTy, IntTy, LitIntType, LitKind, UintTy};
use syntax::ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
use syntax::errors::DiagnosticBuilder;
use syntax::source_map::Span;
use syntax::symbol::{sym, Symbol};
@ -1186,7 +1186,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
}
}
match lit.node {
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {},
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
_ => {
if cast_from.kind == cast_to.kind && !in_external_macro(cx.sess(), expr.span) {
span_lint(

14
clippy_lints/src/utils/author.rs
View File

@ -9,7 +9,7 @@
use rustc::session::Session;
use rustc::{declare_lint_pass, declare_tool_lint};
use rustc_data_structures::fx::FxHashMap;
use syntax::ast::{Attribute, LitKind};
use syntax::ast::{Attribute, LitFloatType, LitKind};
declare_clippy_lint! {
/// **What it does:** Generates clippy code that detects the offending pattern
@ -288,10 +288,14 @@ fn visit_expr(&mut self, expr: &Expr) {
LitKind::Byte(b) => println!(" if let LitKind::Byte({}) = {}.node;", b, lit_pat),
// FIXME: also check int type
LitKind::Int(i, _) => println!(" if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
LitKind::Float(..) => println!(" if let LitKind::Float(..) = {}.node;", lit_pat),
LitKind::FloatUnsuffixed(_) => {
println!(" if let LitKind::FloatUnsuffixed(_) = {}.node;", lit_pat)
},
LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
" if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
lit_pat
),
LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
" if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
lit_pat
),
LitKind::ByteStr(ref vec) => {
let vec_pat = self.next("vec");
println!(" if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);