use std::collections::BTreeMap;
use if_chain::if_chain;
-use rustc::hir;
-use rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
-use rustc::hir::*;
-use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
+use rustc::hir::map::Map;
+use rustc::lint::in_external_macro;
use rustc::ty::layout::LayoutOf;
use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables};
-use rustc::{declare_lint_pass, impl_lint_pass};
-use rustc_errors::Applicability;
-use rustc_session::declare_tool_lint;
+use rustc_errors::{Applicability, DiagnosticBuilder};
+use rustc_hir as hir;
+use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
+use rustc_hir::*;
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+use rustc_span::hygiene::{ExpnKind, MacroKind};
+use rustc_span::source_map::Span;
+use rustc_span::symbol::{sym, Symbol};
use rustc_target::spec::abi::Abi;
use rustc_typeck::hir_ty_to_ty;
use syntax::ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
-use syntax::errors::DiagnosticBuilder;
-use syntax::source_map::Span;
-use syntax::symbol::{sym, Symbol};
-use syntax_pos::hygiene::{ExpnKind, MacroKind};
use crate::consts::{constant, Constant};
use crate::utils::paths;
use crate::utils::{
clip, comparisons, differing_macro_contexts, higher, in_constant, int_bits, last_path_segment, match_def_path,
match_path, method_chain_args, multispan_sugg, qpath_res, same_tys, sext, snippet, snippet_opt,
- snippet_with_applicability, snippet_with_macro_callsite, span_help_and_lint, span_lint, span_lint_and_sugg,
+ snippet_with_applicability, snippet_with_macro_callsite, span_lint, span_lint_and_help, span_lint_and_sugg,
span_lint_and_then, unsext,
};
/// ```
pub LINKEDLIST,
pedantic,
- "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque"
+ "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a `VecDeque`"
}
declare_clippy_lint! {
"a borrow of a boxed type"
}
-declare_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX]);
+pub struct Types {
+ vec_box_size_threshold: u64,
+}
+
+impl_lint_pass!(Types => [BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX]);
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Types {
fn check_fn(
) {
// Skip trait implementations; see issue #605.
if let Some(hir::Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_item(id)) {
- if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.kind {
+ if let ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
return;
}
}
- check_fn_decl(cx, decl);
+ self.check_fn_decl(cx, decl);
}
fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField<'_>) {
- check_ty(cx, &field.ty, false);
+ self.check_ty(cx, &field.ty, false);
}
fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, item: &TraitItem<'_>) {
match item.kind {
- TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => check_ty(cx, ty, false),
- TraitItemKind::Method(ref sig, _) => check_fn_decl(cx, &sig.decl),
+ TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_ty(cx, ty, false),
+ TraitItemKind::Method(ref sig, _) => self.check_fn_decl(cx, &sig.decl),
_ => (),
}
}
fn check_local(&mut self, cx: &LateContext<'_, '_>, local: &Local<'_>) {
if let Some(ref ty) = local.ty {
- check_ty(cx, ty, true);
+ self.check_ty(cx, ty, true);
}
}
}
-fn check_fn_decl(cx: &LateContext<'_, '_>, decl: &FnDecl<'_>) {
- for input in decl.inputs {
- check_ty(cx, input, false);
- }
-
- if let FunctionRetTy::Return(ref ty) = decl.output {
- check_ty(cx, ty, false);
- }
-}
-
/// Checks if `qpath` has last segment with type parameter matching `path`
fn match_type_parameter(cx: &LateContext<'_, '_>, qpath: &QPath<'_>, path: &[&str]) -> bool {
let last = last_path_segment(qpath);
false
}
-/// Recursively check for `TypePass` lints in the given type. Stop at the first
-/// lint found.
-///
-/// The parameter `is_local` distinguishes the context of the type; types from
-/// local bindings should only be checked for the `BORROWED_BOX` lint.
-#[allow(clippy::too_many_lines)]
-fn check_ty(cx: &LateContext<'_, '_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
- if hir_ty.span.from_expansion() {
- return;
+impl Types {
+ pub fn new(vec_box_size_threshold: u64) -> Self {
+ Self { vec_box_size_threshold }
}
- match hir_ty.kind {
- TyKind::Path(ref qpath) if !is_local => {
- let hir_id = hir_ty.hir_id;
- let res = qpath_res(cx, qpath, hir_id);
- if let Some(def_id) = res.opt_def_id() {
- if Some(def_id) == cx.tcx.lang_items().owned_box() {
- if match_type_parameter(cx, qpath, &paths::VEC) {
- span_help_and_lint(
- cx,
- BOX_VEC,
- hir_ty.span,
- "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
- "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation.",
- );
- return; // don't recurse into the type
- }
- } else if cx.tcx.is_diagnostic_item(Symbol::intern("vec_type"), def_id) {
- if_chain! {
- // Get the _ part of Vec<_>
- if let Some(ref last) = last_path_segment(qpath).args;
- if let Some(ty) = last.args.iter().find_map(|arg| match arg {
- GenericArg::Type(ty) => Some(ty),
- _ => None,
- });
- // ty is now _ at this point
- if let TyKind::Path(ref ty_qpath) = ty.kind;
- let res = qpath_res(cx, ty_qpath, ty.hir_id);
- if let Some(def_id) = res.opt_def_id();
- if Some(def_id) == cx.tcx.lang_items().owned_box();
- // At this point, we know ty is Box<T>, now get T
- if let Some(ref last) = last_path_segment(ty_qpath).args;
- if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
- GenericArg::Type(ty) => Some(ty),
- _ => None,
- });
- then {
+
+ fn check_fn_decl(&mut self, cx: &LateContext<'_, '_>, decl: &FnDecl<'_>) {
+ for input in decl.inputs {
+ self.check_ty(cx, input, false);
+ }
+
+ if let FunctionRetTy::Return(ref ty) = decl.output {
+ self.check_ty(cx, ty, false);
+ }
+ }
+
+ /// Recursively check for `TypePass` lints in the given type. Stop at the first
+ /// lint found.
+ ///
+ /// The parameter `is_local` distinguishes the context of the type; types from
+ /// local bindings should only be checked for the `BORROWED_BOX` lint.
+ #[allow(clippy::too_many_lines)]
+ fn check_ty(&mut self, cx: &LateContext<'_, '_>, hir_ty: &hir::Ty<'_>, is_local: bool) {
+ if hir_ty.span.from_expansion() {
+ return;
+ }
+ match hir_ty.kind {
+ TyKind::Path(ref qpath) if !is_local => {
+ let hir_id = hir_ty.hir_id;
+ let res = qpath_res(cx, qpath, hir_id);
+ if let Some(def_id) = res.opt_def_id() {
+ if Some(def_id) == cx.tcx.lang_items().owned_box() {
+ if match_type_parameter(cx, qpath, &paths::VEC) {
+ span_lint_and_help(
+ cx,
+ BOX_VEC,
+ hir_ty.span,
+ "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
+ "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation.",
+ );
+ return; // don't recurse into the type
+ }
+ } else if cx.tcx.is_diagnostic_item(Symbol::intern("vec_type"), def_id) {
+ if_chain! {
+ // Get the _ part of Vec<_>
+ if let Some(ref last) = last_path_segment(qpath).args;
+ if let Some(ty) = last.args.iter().find_map(|arg| match arg {
+ GenericArg::Type(ty) => Some(ty),
+ _ => None,
+ });
+ // ty is now _ at this point
+ if let TyKind::Path(ref ty_qpath) = ty.kind;
+ let res = qpath_res(cx, ty_qpath, ty.hir_id);
+ if let Some(def_id) = res.opt_def_id();
+ if Some(def_id) == cx.tcx.lang_items().owned_box();
+ // At this point, we know ty is Box<T>, now get T
+ if let Some(ref last) = last_path_segment(ty_qpath).args;
+ if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
+ GenericArg::Type(ty) => Some(ty),
+ _ => None,
+ });
let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
- if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env) {
+ if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env);
+ if let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes());
+ if ty_ty_size <= self.vec_box_size_threshold;
+ then {
span_lint_and_sugg(
cx,
VEC_BOX,
return; // don't recurse into the type
}
}
- }
- } else if match_def_path(cx, def_id, &paths::OPTION) {
- if match_type_parameter(cx, qpath, &paths::OPTION) {
- span_lint(
+ } else if match_def_path(cx, def_id, &paths::OPTION) {
+ if match_type_parameter(cx, qpath, &paths::OPTION) {
+ span_lint(
+ cx,
+ OPTION_OPTION,
+ hir_ty.span,
+ "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
+ enum if you need to distinguish all 3 cases",
+ );
+ return; // don't recurse into the type
+ }
+ } else if match_def_path(cx, def_id, &paths::LINKED_LIST) {
+ span_lint_and_help(
cx,
- OPTION_OPTION,
+ LINKEDLIST,
hir_ty.span,
- "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
- enum if you need to distinguish all 3 cases",
+ "I see you're using a LinkedList! Perhaps you meant some other data structure?",
+ "a `VecDeque` might work",
);
return; // don't recurse into the type
}
- } else if match_def_path(cx, def_id, &paths::LINKED_LIST) {
- span_help_and_lint(
- cx,
- LINKEDLIST,
- hir_ty.span,
- "I see you're using a LinkedList! Perhaps you meant some other data structure?",
- "a VecDeque might work",
- );
- return; // don't recurse into the type
}
- }
- match *qpath {
- QPath::Resolved(Some(ref ty), ref p) => {
- check_ty(cx, ty, is_local);
- for ty in p.segments.iter().flat_map(|seg| {
- seg.args
- .as_ref()
- .map_or_else(|| [].iter(), |params| params.args.iter())
- .filter_map(|arg| match arg {
- GenericArg::Type(ty) => Some(ty),
- _ => None,
- })
- }) {
- check_ty(cx, ty, is_local);
- }
- },
- QPath::Resolved(None, ref p) => {
- for ty in p.segments.iter().flat_map(|seg| {
- seg.args
- .as_ref()
- .map_or_else(|| [].iter(), |params| params.args.iter())
- .filter_map(|arg| match arg {
+ match *qpath {
+ QPath::Resolved(Some(ref ty), ref p) => {
+ self.check_ty(cx, ty, is_local);
+ for ty in p.segments.iter().flat_map(|seg| {
+ seg.args
+ .as_ref()
+ .map_or_else(|| [].iter(), |params| params.args.iter())
+ .filter_map(|arg| match arg {
+ GenericArg::Type(ty) => Some(ty),
+ _ => None,
+ })
+ }) {
+ self.check_ty(cx, ty, is_local);
+ }
+ },
+ QPath::Resolved(None, ref p) => {
+ for ty in p.segments.iter().flat_map(|seg| {
+ seg.args
+ .as_ref()
+ .map_or_else(|| [].iter(), |params| params.args.iter())
+ .filter_map(|arg| match arg {
+ GenericArg::Type(ty) => Some(ty),
+ _ => None,
+ })
+ }) {
+ self.check_ty(cx, ty, is_local);
+ }
+ },
+ QPath::TypeRelative(ref ty, ref seg) => {
+ self.check_ty(cx, ty, is_local);
+ if let Some(ref params) = seg.args {
+ for ty in params.args.iter().filter_map(|arg| match arg {
GenericArg::Type(ty) => Some(ty),
_ => None,
- })
- }) {
- check_ty(cx, ty, is_local);
- }
- },
- QPath::TypeRelative(ref ty, ref seg) => {
- check_ty(cx, ty, is_local);
- if let Some(ref params) = seg.args {
- for ty in params.args.iter().filter_map(|arg| match arg {
- GenericArg::Type(ty) => Some(ty),
- _ => None,
- }) {
- check_ty(cx, ty, is_local);
+ }) {
+ self.check_ty(cx, ty, is_local);
+ }
}
- }
- },
- }
- },
- TyKind::Rptr(ref lt, ref mut_ty) => check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
- // recurse
- TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
- check_ty(cx, ty, is_local)
- },
- TyKind::Tup(tys) => {
- for ty in tys {
- check_ty(cx, ty, is_local);
- }
- },
- _ => {},
+ },
+ }
+ },
+ TyKind::Rptr(ref lt, ref mut_ty) => self.check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
+ // recurse
+ TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
+ self.check_ty(cx, ty, is_local)
+ },
+ TyKind::Tup(tys) => {
+ for ty in tys {
+ self.check_ty(cx, ty, is_local);
+ }
+ },
+ _ => {},
+ }
}
-}
-fn check_ty_rptr(cx: &LateContext<'_, '_>, hir_ty: &hir::Ty<'_>, is_local: bool, lt: &Lifetime, mut_ty: &MutTy<'_>) {
- match mut_ty.ty.kind {
- TyKind::Path(ref qpath) => {
- let hir_id = mut_ty.ty.hir_id;
- let def = qpath_res(cx, qpath, hir_id);
- if_chain! {
- if let Some(def_id) = def.opt_def_id();
- if Some(def_id) == cx.tcx.lang_items().owned_box();
- if let QPath::Resolved(None, ref path) = *qpath;
- if let [ref bx] = *path.segments;
- if let Some(ref params) = bx.args;
- if !params.parenthesized;
- if let Some(inner) = params.args.iter().find_map(|arg| match arg {
- GenericArg::Type(ty) => Some(ty),
- _ => None,
- });
- then {
- if is_any_trait(inner) {
- // Ignore `Box<Any>` types; see issue #1884 for details.
- return;
- }
+ fn check_ty_rptr(
+ &mut self,
+ cx: &LateContext<'_, '_>,
+ hir_ty: &hir::Ty<'_>,
+ is_local: bool,
+ lt: &Lifetime,
+ mut_ty: &MutTy<'_>,
+ ) {
+ match mut_ty.ty.kind {
+ TyKind::Path(ref qpath) => {
+ let hir_id = mut_ty.ty.hir_id;
+ let def = qpath_res(cx, qpath, hir_id);
+ if_chain! {
+ if let Some(def_id) = def.opt_def_id();
+ if Some(def_id) == cx.tcx.lang_items().owned_box();
+ if let QPath::Resolved(None, ref path) = *qpath;
+ if let [ref bx] = *path.segments;
+ if let Some(ref params) = bx.args;
+ if !params.parenthesized;
+ if let Some(inner) = params.args.iter().find_map(|arg| match arg {
+ GenericArg::Type(ty) => Some(ty),
+ _ => None,
+ });
+ then {
+ if is_any_trait(inner) {
+ // Ignore `Box<Any>` types; see issue #1884 for details.
+ return;
+ }
- let ltopt = if lt.is_elided() {
- String::new()
- } else {
- format!("{} ", lt.name.ident().as_str())
- };
- let mutopt = if mut_ty.mutbl == Mutability::Mut {
- "mut "
- } else {
- ""
- };
- let mut applicability = Applicability::MachineApplicable;
- span_lint_and_sugg(
- cx,
- BORROWED_BOX,
- hir_ty.span,
- "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
- "try",
- format!(
- "&{}{}{}",
- ltopt,
- mutopt,
- &snippet_with_applicability(cx, inner.span, "..", &mut applicability)
- ),
- Applicability::Unspecified,
- );
- return; // don't recurse into the type
- }
- };
- check_ty(cx, &mut_ty.ty, is_local);
- },
- _ => check_ty(cx, &mut_ty.ty, is_local),
+ let ltopt = if lt.is_elided() {
+ String::new()
+ } else {
+ format!("{} ", lt.name.ident().as_str())
+ };
+ let mutopt = if mut_ty.mutbl == Mutability::Mut {
+ "mut "
+ } else {
+ ""
+ };
+ let mut applicability = Applicability::MachineApplicable;
+ span_lint_and_sugg(
+ cx,
+ BORROWED_BOX,
+ hir_ty.span,
+ "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
+ "try",
+ format!(
+ "&{}{}{}",
+ ltopt,
+ mutopt,
+ &snippet_with_applicability(cx, inner.span, "..", &mut applicability)
+ ),
+ Applicability::Unspecified,
+ );
+ return; // don't recurse into the type
+ }
+ };
+ self.check_ty(cx, &mut_ty.ty, is_local);
+ },
+ _ => self.check_ty(cx, &mut_ty.ty, is_local),
+ }
}
}
/// ```
pub LET_UNIT_VALUE,
style,
- "creating a let binding to a value of unit type, which usually can't be used afterwards"
+ "creating a `let` binding to a value of unit type, which usually can't be used afterwards"
}
declare_lint_pass!(LetUnitValue => [LET_UNIT_VALUE]);
}
fn is_questionmark_desugar_marked_call(expr: &Expr<'_>) -> bool {
- use syntax_pos::hygiene::DesugaringKind;
+ use rustc_span::hygiene::DesugaringKind;
if let ExprKind::Call(ref callee, _) = expr.kind {
callee.span.is_desugaring(DesugaringKind::QuestionMark)
} else {
CAST_PRECISION_LOSS,
expr.span,
&format!(
- "casting {0} to {1} causes a loss of precision {2}({0} is {3} bits wide, but {1}'s mantissa \
- is only {4} bits wide)",
+ "casting `{0}` to `{1}` causes a loss of precision {2}(`{0}` is {3} bits wide, \
+ but `{1}`'s mantissa is only {4} bits wide)",
cast_from,
if cast_to_f64 { "f64" } else { "f32" },
if arch_dependent { arch_dependent_str } else { "" },
CAST_LOSSLESS,
expr.span,
&format!(
- "casting {} to {} may become silently lossy if you later change the type",
+ "casting `{}` to `{}` may become silently lossy if you later change the type",
cast_from, cast_to
),
"try",
cx,
CAST_SIGN_LOSS,
expr.span,
- &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to),
+ &format!(
+ "casting `{}` to `{}` may lose the sign of the value",
+ cast_from, cast_to
+ ),
);
}
CAST_POSSIBLE_TRUNCATION,
expr.span,
&format!(
- "casting {} to {} may truncate the value{}",
+ "casting `{}` to `{}` may truncate the value{}",
cast_from,
cast_to,
match suffix_truncation {
CAST_POSSIBLE_WRAP,
expr.span,
&format!(
- "casting {} to {} may wrap around the value{}",
+ "casting `{}` to `{}` may wrap around the value{}",
cast_from,
cast_to,
match suffix_wrap {
cx,
UNNECESSARY_CAST,
expr.span,
- &format!("casting integer literal to {} is unnecessary", cast_to),
+ &format!("casting integer literal to `{}` is unnecessary", cast_to),
"try",
format!("{}_{}", n, cast_to),
Applicability::MachineApplicable,
cx,
CAST_POSSIBLE_TRUNCATION,
expr.span,
- &format!("casting {} to {} may truncate the value", cast_from, cast_to),
+ &format!("casting `{}` to `{}` may truncate the value", cast_from, cast_to),
);
if !cast_to.is_signed() {
span_lint(
cx,
CAST_SIGN_LOSS,
expr.span,
- &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to),
+ &format!(
+ "casting `{}` to `{}` may lose the sign of the value",
+ cast_from, cast_to
+ ),
);
}
},
cx,
CAST_POSSIBLE_TRUNCATION,
expr.span,
- "casting f64 to f32 may truncate the value",
+ "casting `f64` to `f32` may truncate the value",
);
}
if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.kind, &cast_to.kind) {
for arg in decl.inputs {
self.check_type(cx, arg);
}
- if let Return(ref ty) = decl.output {
+ if let FunctionRetTy::Return(ref ty) = decl.output {
self.check_type(cx, ty);
}
}
}
impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
+ type Map = Map<'tcx>;
+
fn visit_ty(&mut self, ty: &'tcx hir::Ty<'_>) {
let (add_score, sub_nest) = match ty.kind {
// _, &x and *x have only small overhead; don't mess with nesting level
walk_ty(self, ty);
self.nest -= sub_nest;
}
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
NestedVisitorMap::None
}
}
/// ```
pub CHAR_LIT_AS_U8,
complexity,
- "casting a character literal to u8 truncates"
+ "casting a character literal to `u8` truncates"
}
declare_lint_pass!(CharLitAsU8 => [CHAR_LIT_AS_U8]);
AlwaysFalse => "this comparison is always false".to_owned(),
AlwaysTrue => "this comparison is always true".to_owned(),
InequalityImpossible => format!(
- "the case where the two sides are not equal never occurs, consider using {} == {} \
+ "the case where the two sides are not equal never occurs, consider using `{} == {}` \
instead",
snippet(cx, lhs.span, "lhs"),
snippet(cx, rhs.span, "rhs")
};
let help = format!(
- "because {} is the {} value for this type, {}",
+ "because `{}` is the {} value for this type, {}",
snippet(cx, culprit.expr.span, "x"),
match culprit.which {
Minimum => "minimum",
conclusion
);
- span_help_and_lint(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, &help);
+ span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, &help);
}
}
}
impl PartialEq for FullInt {
#[must_use]
fn eq(&self, other: &Self) -> bool {
- self.partial_cmp(other).expect("partial_cmp only returns Some(_)") == Ordering::Equal
+ self.partial_cmp(other).expect("`partial_cmp` only returns `Some(_)`") == Ordering::Equal
}
}
#[must_use]
fn cmp(&self, other: &Self) -> Ordering {
self.partial_cmp(other)
- .expect("partial_cmp for FullInt can never return None")
+ .expect("`partial_cmp` for FullInt can never return `None`")
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher {
#[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item<'_>) {
- use syntax_pos::BytePos;
+ use rustc_span::BytePos;
fn suggestion<'a, 'tcx>(
cx: &LateContext<'a, 'tcx>,
}
match item.kind {
- ItemKind::Impl(_, _, _, ref generics, _, ref ty, ref items) => {
+ ItemKind::Impl {
+ ref generics,
+ self_ty: ref ty,
+ ref items,
+ ..
+ } => {
let mut vis = ImplicitHasherTypeVisitor::new(cx);
vis.visit_ty(ty);
}
impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
+ type Map = Map<'tcx>;
+
fn visit_ty(&mut self, t: &'tcx hir::Ty<'_>) {
if let Some(target) = ImplicitHasherType::new(self.cx, t) {
self.found.push(target);
walk_ty(self, t);
}
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
NestedVisitorMap::None
}
}
}
impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+ type Map = Map<'tcx>;
+
fn visit_body(&mut self, body: &'tcx Body<'_>) {
let prev_body = self.body;
self.body = self.cx.tcx.body_tables(body.id());
walk_expr(self, e);
}
- fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+ fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir())
}
}
cx,
CAST_REF_TO_MUT,
expr.span,
- "casting &T to &mut T may cause undefined behaviour, consider instead using an UnsafeCell",
+ "casting `&T` to `&mut T` may cause undefined behavior, consider instead using an `UnsafeCell`",
);
}
}
projects / rust.git / blobdiff