]> git.lizzy.rs Git - rust.git/blob - clippy_lints/src/types.rs
Auto merge of #3879 - phansch:rustfix_string_lit_as_bytes, r=flip1995
[rust.git] / clippy_lints / src / types.rs
1 #![allow(clippy::default_hash_types)]
2
3 use std::borrow::Cow;
4 use std::cmp::Ordering;
5 use std::collections::BTreeMap;
6
7 use if_chain::if_chain;
8 use rustc::hir;
9 use rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
10 use rustc::hir::*;
11 use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
12 use rustc::ty::layout::LayoutOf;
13 use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables};
14 use rustc::{declare_tool_lint, lint_array};
15 use rustc_errors::Applicability;
16 use rustc_target::spec::abi::Abi;
17 use rustc_typeck::hir_ty_to_ty;
18 use syntax::ast::{FloatTy, IntTy, UintTy};
19 use syntax::errors::DiagnosticBuilder;
20 use syntax::source_map::Span;
21
22 use crate::consts::{constant, Constant};
23 use crate::utils::paths;
24 use crate::utils::{
25     clip, comparisons, differing_macro_contexts, higher, in_constant, in_macro, int_bits, last_path_segment,
26     match_def_path, match_path, multispan_sugg, same_tys, sext, snippet, snippet_opt, snippet_with_applicability,
27     span_help_and_lint, span_lint, span_lint_and_sugg, span_lint_and_then, unsext, AbsolutePathBuffer,
28 };
29
30 /// Handles all the linting of funky types
31 pub struct TypePass;
32
33 declare_clippy_lint! {
34     /// **What it does:** Checks for use of `Box<Vec<_>>` anywhere in the code.
35     ///
36     /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
37     /// the heap. So if you `Box` it, you just add another level of indirection
38     /// without any benefit whatsoever.
39     ///
40     /// **Known problems:** None.
41     ///
42     /// **Example:**
43     /// ```rust,ignore
44     /// struct X {
45     ///     values: Box<Vec<Foo>>,
46     /// }
47     /// ```
48     ///
49     /// Better:
50     ///
51     /// ```rust,ignore
52     /// struct X {
53     ///     values: Vec<Foo>,
54     /// }
55     /// ```
56     pub BOX_VEC,
57     perf,
58     "usage of `Box<Vec<T>>`, vector elements are already on the heap"
59 }
60
61 declare_clippy_lint! {
62     /// **What it does:** Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.
63     ///
64     /// **Why is this bad?** `Vec` already keeps its contents in a separate area on
65     /// the heap. So if you `Box` its contents, you just add another level of indirection.
66     ///
67     /// **Known problems:** Vec<Box<T: Sized>> makes sense if T is a large type (see #3530,
68     /// 1st comment).
69     ///
70     /// **Example:**
71     /// ```rust
72     /// struct X {
73     ///     values: Vec<Box<i32>>,
74     /// }
75     /// ```
76     ///
77     /// Better:
78     ///
79     /// ```rust
80     /// struct X {
81     ///     values: Vec<i32>,
82     /// }
83     /// ```
84     pub VEC_BOX,
85     complexity,
86     "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap"
87 }
88
89 declare_clippy_lint! {
90     /// **What it does:** Checks for use of `Option<Option<_>>` in function signatures and type
91     /// definitions
92     ///
93     /// **Why is this bad?** `Option<_>` represents an optional value. `Option<Option<_>>`
94     /// represents an optional optional value which is logically the same thing as an optional
95     /// value but has an unneeded extra level of wrapping.
96     ///
97     /// **Known problems:** None.
98     ///
99     /// **Example**
100     /// ```rust
101     /// fn x() -> Option<Option<u32>> {
102     ///     None
103     /// }
104     /// ```
105     pub OPTION_OPTION,
106     complexity,
107     "usage of `Option<Option<T>>`"
108 }
109
110 declare_clippy_lint! {
111     /// **What it does:** Checks for usage of any `LinkedList`, suggesting to use a
112     /// `Vec` or a `VecDeque` (formerly called `RingBuf`).
113     ///
114     /// **Why is this bad?** Gankro says:
115     ///
116     /// > The TL;DR of `LinkedList` is that it's built on a massive amount of
117     /// pointers and indirection.
118     /// > It wastes memory, it has terrible cache locality, and is all-around slow.
119     /// `RingBuf`, while
120     /// > "only" amortized for push/pop, should be faster in the general case for
121     /// almost every possible
122     /// > workload, and isn't even amortized at all if you can predict the capacity
123     /// you need.
124     /// >
125     /// > `LinkedList`s are only really good if you're doing a lot of merging or
126     /// splitting of lists.
127     /// > This is because they can just mangle some pointers instead of actually
128     /// copying the data. Even
129     /// > if you're doing a lot of insertion in the middle of the list, `RingBuf`
130     /// can still be better
131     /// > because of how expensive it is to seek to the middle of a `LinkedList`.
132     ///
133     /// **Known problems:** False positives – the instances where using a
134     /// `LinkedList` makes sense are few and far between, but they can still happen.
135     ///
136     /// **Example:**
137     /// ```rust
138     /// let x = LinkedList::new();
139     /// ```
140     pub LINKEDLIST,
141     pedantic,
142     "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque"
143 }
144
145 declare_clippy_lint! {
146     /// **What it does:** Checks for use of `&Box<T>` anywhere in the code.
147     ///
148     /// **Why is this bad?** Any `&Box<T>` can also be a `&T`, which is more
149     /// general.
150     ///
151     /// **Known problems:** None.
152     ///
153     /// **Example:**
154     /// ```rust,ignore
155     /// fn foo(bar: &Box<T>) { ... }
156     /// ```
157     ///
158     /// Better:
159     ///
160     /// ```rust,ignore
161     /// fn foo(bar: &T) { ... }
162     /// ```
163     pub BORROWED_BOX,
164     complexity,
165     "a borrow of a boxed type"
166 }
167
168 impl LintPass for TypePass {
169     fn get_lints(&self) -> LintArray {
170         lint_array!(BOX_VEC, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX)
171     }
172
173     fn name(&self) -> &'static str {
174         "Types"
175     }
176 }
177
178 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass {
179     fn check_fn(&mut self, cx: &LateContext<'_, '_>, _: FnKind<'_>, decl: &FnDecl, _: &Body, _: Span, id: HirId) {
180         // Skip trait implementations; see issue #605.
181         if let Some(hir::Node::Item(item)) = cx.tcx.hir().find_by_hir_id(cx.tcx.hir().get_parent_item(id)) {
182             if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.node {
183                 return;
184             }
185         }
186
187         check_fn_decl(cx, decl);
188     }
189
190     fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField) {
191         check_ty(cx, &field.ty, false);
192     }
193
194     fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, item: &TraitItem) {
195         match item.node {
196             TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => check_ty(cx, ty, false),
197             TraitItemKind::Method(ref sig, _) => check_fn_decl(cx, &sig.decl),
198             _ => (),
199         }
200     }
201
202     fn check_local(&mut self, cx: &LateContext<'_, '_>, local: &Local) {
203         if let Some(ref ty) = local.ty {
204             check_ty(cx, ty, true);
205         }
206     }
207 }
208
209 fn check_fn_decl(cx: &LateContext<'_, '_>, decl: &FnDecl) {
210     for input in &decl.inputs {
211         check_ty(cx, input, false);
212     }
213
214     if let FunctionRetTy::Return(ref ty) = decl.output {
215         check_ty(cx, ty, false);
216     }
217 }
218
219 /// Checks if `qpath` has last segment with type parameter matching `path`
220 fn match_type_parameter(cx: &LateContext<'_, '_>, qpath: &QPath, path: &[&str]) -> bool {
221     let last = last_path_segment(qpath);
222     if_chain! {
223         if let Some(ref params) = last.args;
224         if !params.parenthesized;
225         if let Some(ty) = params.args.iter().find_map(|arg| match arg {
226             GenericArg::Type(ty) => Some(ty),
227             _ => None,
228         });
229         if let TyKind::Path(ref qpath) = ty.node;
230         if let Some(did) = cx.tables.qpath_def(qpath, ty.hir_id).opt_def_id();
231         if match_def_path(cx.tcx, did, path);
232         then {
233             return true;
234         }
235     }
236     false
237 }
238
239 /// Recursively check for `TypePass` lints in the given type. Stop at the first
240 /// lint found.
241 ///
242 /// The parameter `is_local` distinguishes the context of the type; types from
243 /// local bindings should only be checked for the `BORROWED_BOX` lint.
244 #[allow(clippy::too_many_lines)]
245 fn check_ty(cx: &LateContext<'_, '_>, hir_ty: &hir::Ty, is_local: bool) {
246     if in_macro(hir_ty.span) {
247         return;
248     }
249     match hir_ty.node {
250         TyKind::Path(ref qpath) if !is_local => {
251             let hir_id = hir_ty.hir_id;
252             let def = cx.tables.qpath_def(qpath, hir_id);
253             if let Some(def_id) = def.opt_def_id() {
254                 if Some(def_id) == cx.tcx.lang_items().owned_box() {
255                     if match_type_parameter(cx, qpath, &paths::VEC) {
256                         span_help_and_lint(
257                             cx,
258                             BOX_VEC,
259                             hir_ty.span,
260                             "you seem to be trying to use `Box<Vec<T>>`. Consider using just `Vec<T>`",
261                             "`Vec<T>` is already on the heap, `Box<Vec<T>>` makes an extra allocation.",
262                         );
263                         return; // don't recurse into the type
264                     }
265                 } else if match_def_path(cx.tcx, def_id, &paths::VEC) {
266                     if_chain! {
267                         // Get the _ part of Vec<_>
268                         if let Some(ref last) = last_path_segment(qpath).args;
269                         if let Some(ty) = last.args.iter().find_map(|arg| match arg {
270                             GenericArg::Type(ty) => Some(ty),
271                             _ => None,
272                         });
273                         // ty is now _ at this point
274                         if let TyKind::Path(ref ty_qpath) = ty.node;
275                         let def = cx.tables.qpath_def(ty_qpath, ty.hir_id);
276                         if let Some(def_id) = def.opt_def_id();
277                         if Some(def_id) == cx.tcx.lang_items().owned_box();
278                         // At this point, we know ty is Box<T>, now get T
279                         if let Some(ref last) = last_path_segment(ty_qpath).args;
280                         if let Some(boxed_ty) = last.args.iter().find_map(|arg| match arg {
281                             GenericArg::Type(ty) => Some(ty),
282                             _ => None,
283                         });
284                         then {
285                             let ty_ty = hir_ty_to_ty(cx.tcx, boxed_ty);
286                             if ty_ty.is_sized(cx.tcx.at(ty.span), cx.param_env) {
287                                 span_lint_and_sugg(
288                                     cx,
289                                     VEC_BOX,
290                                     hir_ty.span,
291                                     "`Vec<T>` is already on the heap, the boxing is unnecessary.",
292                                     "try",
293                                     format!("Vec<{}>", ty_ty),
294                                     Applicability::MachineApplicable,
295                                 );
296                                 return; // don't recurse into the type
297                             }
298                         }
299                     }
300                 } else if match_def_path(cx.tcx, def_id, &paths::OPTION) {
301                     if match_type_parameter(cx, qpath, &paths::OPTION) {
302                         span_lint(
303                             cx,
304                             OPTION_OPTION,
305                             hir_ty.span,
306                             "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
307                              enum if you need to distinguish all 3 cases",
308                         );
309                         return; // don't recurse into the type
310                     }
311                 } else if match_def_path(cx.tcx, def_id, &paths::LINKED_LIST) {
312                     span_help_and_lint(
313                         cx,
314                         LINKEDLIST,
315                         hir_ty.span,
316                         "I see you're using a LinkedList! Perhaps you meant some other data structure?",
317                         "a VecDeque might work",
318                     );
319                     return; // don't recurse into the type
320                 }
321             }
322             match *qpath {
323                 QPath::Resolved(Some(ref ty), ref p) => {
324                     check_ty(cx, ty, is_local);
325                     for ty in p.segments.iter().flat_map(|seg| {
326                         seg.args
327                             .as_ref()
328                             .map_or_else(|| [].iter(), |params| params.args.iter())
329                             .filter_map(|arg| match arg {
330                                 GenericArg::Type(ty) => Some(ty),
331                                 _ => None,
332                             })
333                     }) {
334                         check_ty(cx, ty, is_local);
335                     }
336                 },
337                 QPath::Resolved(None, ref p) => {
338                     for ty in p.segments.iter().flat_map(|seg| {
339                         seg.args
340                             .as_ref()
341                             .map_or_else(|| [].iter(), |params| params.args.iter())
342                             .filter_map(|arg| match arg {
343                                 GenericArg::Type(ty) => Some(ty),
344                                 _ => None,
345                             })
346                     }) {
347                         check_ty(cx, ty, is_local);
348                     }
349                 },
350                 QPath::TypeRelative(ref ty, ref seg) => {
351                     check_ty(cx, ty, is_local);
352                     if let Some(ref params) = seg.args {
353                         for ty in params.args.iter().filter_map(|arg| match arg {
354                             GenericArg::Type(ty) => Some(ty),
355                             _ => None,
356                         }) {
357                             check_ty(cx, ty, is_local);
358                         }
359                     }
360                 },
361             }
362         },
363         TyKind::Rptr(ref lt, ref mut_ty) => check_ty_rptr(cx, hir_ty, is_local, lt, mut_ty),
364         // recurse
365         TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
366             check_ty(cx, ty, is_local)
367         },
368         TyKind::Tup(ref tys) => {
369             for ty in tys {
370                 check_ty(cx, ty, is_local);
371             }
372         },
373         _ => {},
374     }
375 }
376
377 fn check_ty_rptr(cx: &LateContext<'_, '_>, hir_ty: &hir::Ty, is_local: bool, lt: &Lifetime, mut_ty: &MutTy) {
378     match mut_ty.ty.node {
379         TyKind::Path(ref qpath) => {
380             let hir_id = mut_ty.ty.hir_id;
381             let def = cx.tables.qpath_def(qpath, hir_id);
382             if_chain! {
383                 if let Some(def_id) = def.opt_def_id();
384                 if Some(def_id) == cx.tcx.lang_items().owned_box();
385                 if let QPath::Resolved(None, ref path) = *qpath;
386                 if let [ref bx] = *path.segments;
387                 if let Some(ref params) = bx.args;
388                 if !params.parenthesized;
389                 if let Some(inner) = params.args.iter().find_map(|arg| match arg {
390                     GenericArg::Type(ty) => Some(ty),
391                     _ => None,
392                 });
393                 then {
394                     if is_any_trait(inner) {
395                         // Ignore `Box<Any>` types; see issue #1884 for details.
396                         return;
397                     }
398
399                     let ltopt = if lt.is_elided() {
400                         String::new()
401                     } else {
402                         format!("{} ", lt.name.ident().as_str())
403                     };
404                     let mutopt = if mut_ty.mutbl == Mutability::MutMutable {
405                         "mut "
406                     } else {
407                         ""
408                     };
409                     let mut applicability = Applicability::MachineApplicable;
410                     span_lint_and_sugg(
411                         cx,
412                         BORROWED_BOX,
413                         hir_ty.span,
414                         "you seem to be trying to use `&Box<T>`. Consider using just `&T`",
415                         "try",
416                         format!(
417                             "&{}{}{}",
418                             ltopt,
419                             mutopt,
420                             &snippet_with_applicability(cx, inner.span, "..", &mut applicability)
421                         ),
422                         Applicability::Unspecified,
423                     );
424                     return; // don't recurse into the type
425                 }
426             };
427             check_ty(cx, &mut_ty.ty, is_local);
428         },
429         _ => check_ty(cx, &mut_ty.ty, is_local),
430     }
431 }
432
433 // Returns true if given type is `Any` trait.
434 fn is_any_trait(t: &hir::Ty) -> bool {
435     if_chain! {
436         if let TyKind::TraitObject(ref traits, _) = t.node;
437         if traits.len() >= 1;
438         // Only Send/Sync can be used as additional traits, so it is enough to
439         // check only the first trait.
440         if match_path(&traits[0].trait_ref.path, &paths::ANY_TRAIT);
441         then {
442             return true;
443         }
444     }
445
446     false
447 }
448
449 pub struct LetPass;
450
451 declare_clippy_lint! {
452     /// **What it does:** Checks for binding a unit value.
453     ///
454     /// **Why is this bad?** A unit value cannot usefully be used anywhere. So
455     /// binding one is kind of pointless.
456     ///
457     /// **Known problems:** None.
458     ///
459     /// **Example:**
460     /// ```rust
461     /// let x = {
462     ///     1;
463     /// };
464     /// ```
465     pub LET_UNIT_VALUE,
466     style,
467     "creating a let binding to a value of unit type, which usually can't be used afterwards"
468 }
469
470 impl LintPass for LetPass {
471     fn get_lints(&self) -> LintArray {
472         lint_array!(LET_UNIT_VALUE)
473     }
474
475     fn name(&self) -> &'static str {
476         "LetUnitValue"
477     }
478 }
479
480 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetPass {
481     fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
482         if let StmtKind::Local(ref local) = stmt.node {
483             if is_unit(cx.tables.pat_ty(&local.pat)) {
484                 if in_external_macro(cx.sess(), stmt.span) || in_macro(local.pat.span) {
485                     return;
486                 }
487                 if higher::is_from_for_desugar(local) {
488                     return;
489                 }
490                 span_lint(
491                     cx,
492                     LET_UNIT_VALUE,
493                     stmt.span,
494                     &format!(
495                         "this let-binding has unit value. Consider omitting `let {} =`",
496                         snippet(cx, local.pat.span, "..")
497                     ),
498                 );
499             }
500         }
501     }
502 }
503
504 declare_clippy_lint! {
505     /// **What it does:** Checks for comparisons to unit.
506     ///
507     /// **Why is this bad?** Unit is always equal to itself, and thus is just a
508     /// clumsily written constant. Mostly this happens when someone accidentally
509     /// adds semicolons at the end of the operands.
510     ///
511     /// **Known problems:** None.
512     ///
513     /// **Example:**
514     /// ```rust
515     /// # fn foo() {};
516     /// # fn bar() {};
517     /// # fn baz() {};
518     /// if {
519     ///     foo();
520     /// } == {
521     ///     bar();
522     /// } {
523     ///     baz();
524     /// }
525     /// ```
526     /// is equal to
527     /// ```rust
528     /// # fn foo() {};
529     /// # fn bar() {};
530     /// # fn baz() {};
531     /// {
532     ///     foo();
533     ///     bar();
534     ///     baz();
535     /// }
536     /// ```
537     pub UNIT_CMP,
538     correctness,
539     "comparing unit values"
540 }
541
542 pub struct UnitCmp;
543
544 impl LintPass for UnitCmp {
545     fn get_lints(&self) -> LintArray {
546         lint_array!(UNIT_CMP)
547     }
548
549     fn name(&self) -> &'static str {
550         "UnicCmp"
551     }
552 }
553
554 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitCmp {
555     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
556         if in_macro(expr.span) {
557             return;
558         }
559         if let ExprKind::Binary(ref cmp, ref left, _) = expr.node {
560             let op = cmp.node;
561             if op.is_comparison() && is_unit(cx.tables.expr_ty(left)) {
562                 let result = match op {
563                     BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true",
564                     _ => "false",
565                 };
566                 span_lint(
567                     cx,
568                     UNIT_CMP,
569                     expr.span,
570                     &format!(
571                         "{}-comparison of unit values detected. This will always be {}",
572                         op.as_str(),
573                         result
574                     ),
575                 );
576             }
577         }
578     }
579 }
580
581 declare_clippy_lint! {
582     /// **What it does:** Checks for passing a unit value as an argument to a function without using a
583     /// unit literal (`()`).
584     ///
585     /// **Why is this bad?** This is likely the result of an accidental semicolon.
586     ///
587     /// **Known problems:** None.
588     ///
589     /// **Example:**
590     /// ```rust
591     /// foo({
592     ///     let a = bar();
593     ///     baz(a);
594     /// })
595     /// ```
596     pub UNIT_ARG,
597     complexity,
598     "passing unit to a function"
599 }
600
601 pub struct UnitArg;
602
603 impl LintPass for UnitArg {
604     fn get_lints(&self) -> LintArray {
605         lint_array!(UNIT_ARG)
606     }
607
608     fn name(&self) -> &'static str {
609         "UnitArg"
610     }
611 }
612
613 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg {
614     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
615         if in_macro(expr.span) {
616             return;
617         }
618
619         // apparently stuff in the desugaring of `?` can trigger this
620         // so check for that here
621         // only the calls to `Try::from_error` is marked as desugared,
622         // so we need to check both the current Expr and its parent.
623         if is_questionmark_desugar_marked_call(expr) {
624             return;
625         }
626         if_chain! {
627             let map = &cx.tcx.hir();
628             let opt_parent_node = map.find_by_hir_id(map.get_parent_node_by_hir_id(expr.hir_id));
629             if let Some(hir::Node::Expr(parent_expr)) = opt_parent_node;
630             if is_questionmark_desugar_marked_call(parent_expr);
631             then {
632                 return;
633             }
634         }
635
636         match expr.node {
637             ExprKind::Call(_, ref args) | ExprKind::MethodCall(_, _, ref args) => {
638                 for arg in args {
639                     if is_unit(cx.tables.expr_ty(arg)) && !is_unit_literal(arg) {
640                         if let ExprKind::Match(.., match_source) = &arg.node {
641                             if *match_source == MatchSource::TryDesugar {
642                                 continue;
643                             }
644                         }
645
646                         span_lint_and_sugg(
647                             cx,
648                             UNIT_ARG,
649                             arg.span,
650                             "passing a unit value to a function",
651                             "if you intended to pass a unit value, use a unit literal instead",
652                             "()".to_string(),
653                             Applicability::MachineApplicable,
654                         );
655                     }
656                 }
657             },
658             _ => (),
659         }
660     }
661 }
662
663 fn is_questionmark_desugar_marked_call(expr: &Expr) -> bool {
664     use syntax_pos::hygiene::CompilerDesugaringKind;
665     if let ExprKind::Call(ref callee, _) = expr.node {
666         callee.span.is_compiler_desugaring(CompilerDesugaringKind::QuestionMark)
667     } else {
668         false
669     }
670 }
671
672 fn is_unit(ty: Ty<'_>) -> bool {
673     match ty.sty {
674         ty::Tuple(slice) if slice.is_empty() => true,
675         _ => false,
676     }
677 }
678
679 fn is_unit_literal(expr: &Expr) -> bool {
680     match expr.node {
681         ExprKind::Tup(ref slice) if slice.is_empty() => true,
682         _ => false,
683     }
684 }
685
686 pub struct CastPass;
687
688 declare_clippy_lint! {
689     /// **What it does:** Checks for casts from any numerical to a float type where
690     /// the receiving type cannot store all values from the original type without
691     /// rounding errors. This possible rounding is to be expected, so this lint is
692     /// `Allow` by default.
693     ///
694     /// Basically, this warns on casting any integer with 32 or more bits to `f32`
695     /// or any 64-bit integer to `f64`.
696     ///
697     /// **Why is this bad?** It's not bad at all. But in some applications it can be
698     /// helpful to know where precision loss can take place. This lint can help find
699     /// those places in the code.
700     ///
701     /// **Known problems:** None.
702     ///
703     /// **Example:**
704     /// ```rust
705     /// let x = u64::MAX;
706     /// x as f64
707     /// ```
708     pub CAST_PRECISION_LOSS,
709     pedantic,
710     "casts that cause loss of precision, e.g., `x as f32` where `x: u64`"
711 }
712
713 declare_clippy_lint! {
714     /// **What it does:** Checks for casts from a signed to an unsigned numerical
715     /// type. In this case, negative values wrap around to large positive values,
716     /// which can be quite surprising in practice. However, as the cast works as
717     /// defined, this lint is `Allow` by default.
718     ///
719     /// **Why is this bad?** Possibly surprising results. You can activate this lint
720     /// as a one-time check to see where numerical wrapping can arise.
721     ///
722     /// **Known problems:** None.
723     ///
724     /// **Example:**
725     /// ```rust
726     /// let y: i8 = -1;
727     /// y as u128 // will return 18446744073709551615
728     /// ```
729     pub CAST_SIGN_LOSS,
730     pedantic,
731     "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`"
732 }
733
734 declare_clippy_lint! {
735     /// **What it does:** Checks for on casts between numerical types that may
736     /// truncate large values. This is expected behavior, so the cast is `Allow` by
737     /// default.
738     ///
739     /// **Why is this bad?** In some problem domains, it is good practice to avoid
740     /// truncation. This lint can be activated to help assess where additional
741     /// checks could be beneficial.
742     ///
743     /// **Known problems:** None.
744     ///
745     /// **Example:**
746     /// ```rust
747     /// fn as_u8(x: u64) -> u8 {
748     ///     x as u8
749     /// }
750     /// ```
751     pub CAST_POSSIBLE_TRUNCATION,
752     pedantic,
753     "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`"
754 }
755
756 declare_clippy_lint! {
757     /// **What it does:** Checks for casts from an unsigned type to a signed type of
758     /// the same size. Performing such a cast is a 'no-op' for the compiler,
759     /// i.e., nothing is changed at the bit level, and the binary representation of
760     /// the value is reinterpreted. This can cause wrapping if the value is too big
761     /// for the target signed type. However, the cast works as defined, so this lint
762     /// is `Allow` by default.
763     ///
764     /// **Why is this bad?** While such a cast is not bad in itself, the results can
765     /// be surprising when this is not the intended behavior, as demonstrated by the
766     /// example below.
767     ///
768     /// **Known problems:** None.
769     ///
770     /// **Example:**
771     /// ```rust
772     /// u32::MAX as i32 // will yield a value of `-1`
773     /// ```
774     pub CAST_POSSIBLE_WRAP,
775     pedantic,
776     "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`"
777 }
778
779 declare_clippy_lint! {
780     /// **What it does:** Checks for on casts between numerical types that may
781     /// be replaced by safe conversion functions.
782     ///
783     /// **Why is this bad?** Rust's `as` keyword will perform many kinds of
784     /// conversions, including silently lossy conversions. Conversion functions such
785     /// as `i32::from` will only perform lossless conversions. Using the conversion
786     /// functions prevents conversions from turning into silent lossy conversions if
787     /// the types of the input expressions ever change, and make it easier for
788     /// people reading the code to know that the conversion is lossless.
789     ///
790     /// **Known problems:** None.
791     ///
792     /// **Example:**
793     /// ```rust
794     /// fn as_u64(x: u8) -> u64 {
795     ///     x as u64
796     /// }
797     /// ```
798     ///
799     /// Using `::from` would look like this:
800     ///
801     /// ```rust
802     /// fn as_u64(x: u8) -> u64 {
803     ///     u64::from(x)
804     /// }
805     /// ```
806     pub CAST_LOSSLESS,
807     complexity,
808     "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`"
809 }
810
811 declare_clippy_lint! {
812     /// **What it does:** Checks for casts to the same type.
813     ///
814     /// **Why is this bad?** It's just unnecessary.
815     ///
816     /// **Known problems:** None.
817     ///
818     /// **Example:**
819     /// ```rust
820     /// let _ = 2i32 as i32
821     /// ```
822     pub UNNECESSARY_CAST,
823     complexity,
824     "cast to the same type, e.g., `x as i32` where `x: i32`"
825 }
826
827 declare_clippy_lint! {
828     /// **What it does:** Checks for casts from a less-strictly-aligned pointer to a
829     /// more-strictly-aligned pointer
830     ///
831     /// **Why is this bad?** Dereferencing the resulting pointer may be undefined
832     /// behavior.
833     ///
834     /// **Known problems:** None.
835     ///
836     /// **Example:**
837     /// ```rust
838     /// let _ = (&1u8 as *const u8) as *const u16;
839     /// let _ = (&mut 1u8 as *mut u8) as *mut u16;
840     /// ```
841     pub CAST_PTR_ALIGNMENT,
842     correctness,
843     "cast from a pointer to a more-strictly-aligned pointer"
844 }
845
846 declare_clippy_lint! {
847     /// **What it does:** Checks for casts of function pointers to something other than usize
848     ///
849     /// **Why is this bad?**
850     /// Casting a function pointer to anything other than usize/isize is not portable across
851     /// architectures, because you end up losing bits if the target type is too small or end up with a
852     /// bunch of extra bits that waste space and add more instructions to the final binary than
853     /// strictly necessary for the problem
854     ///
855     /// Casting to isize also doesn't make sense since there are no signed addresses.
856     ///
857     /// **Example**
858     ///
859     /// ```rust
860     /// // Bad
861     /// fn fun() -> i32 { 1 }
862     /// let a = fun as i64;
863     ///
864     /// // Good
865     /// fn fun2() -> i32 { 1 }
866     /// let a = fun2 as usize;
867     /// ```
868     pub FN_TO_NUMERIC_CAST,
869     style,
870     "casting a function pointer to a numeric type other than usize"
871 }
872
873 declare_clippy_lint! {
874     /// **What it does:** Checks for casts of a function pointer to a numeric type not wide enough to
875     /// store address.
876     ///
877     /// **Why is this bad?**
878     /// Such a cast discards some bits of the function's address. If this is intended, it would be more
879     /// clearly expressed by casting to usize first, then casting the usize to the intended type (with
880     /// a comment) to perform the truncation.
881     ///
882     /// **Example**
883     ///
884     /// ```rust
885     /// // Bad
886     /// fn fn1() -> i16 {
887     ///     1
888     /// };
889     /// let _ = fn1 as i32;
890     ///
891     /// // Better: Cast to usize first, then comment with the reason for the truncation
892     /// fn fn2() -> i16 {
893     ///     1
894     /// };
895     /// let fn_ptr = fn2 as usize;
896     /// let fn_ptr_truncated = fn_ptr as i32;
897     /// ```
898     pub FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
899     style,
900     "casting a function pointer to a numeric type not wide enough to store the address"
901 }
902
903 /// Returns the size in bits of an integral type.
904 /// Will return 0 if the type is not an int or uint variant
905 fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_, '_, '_>) -> u64 {
906     match typ.sty {
907         ty::Int(i) => match i {
908             IntTy::Isize => tcx.data_layout.pointer_size.bits(),
909             IntTy::I8 => 8,
910             IntTy::I16 => 16,
911             IntTy::I32 => 32,
912             IntTy::I64 => 64,
913             IntTy::I128 => 128,
914         },
915         ty::Uint(i) => match i {
916             UintTy::Usize => tcx.data_layout.pointer_size.bits(),
917             UintTy::U8 => 8,
918             UintTy::U16 => 16,
919             UintTy::U32 => 32,
920             UintTy::U64 => 64,
921             UintTy::U128 => 128,
922         },
923         _ => 0,
924     }
925 }
926
927 fn is_isize_or_usize(typ: Ty<'_>) -> bool {
928     match typ.sty {
929         ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize) => true,
930         _ => false,
931     }
932 }
933
934 fn span_precision_loss_lint(cx: &LateContext<'_, '_>, expr: &Expr, cast_from: Ty<'_>, cast_to_f64: bool) {
935     let mantissa_nbits = if cast_to_f64 { 52 } else { 23 };
936     let arch_dependent = is_isize_or_usize(cast_from) && cast_to_f64;
937     let arch_dependent_str = "on targets with 64-bit wide pointers ";
938     let from_nbits_str = if arch_dependent {
939         "64".to_owned()
940     } else if is_isize_or_usize(cast_from) {
941         "32 or 64".to_owned()
942     } else {
943         int_ty_to_nbits(cast_from, cx.tcx).to_string()
944     };
945     span_lint(
946         cx,
947         CAST_PRECISION_LOSS,
948         expr.span,
949         &format!(
950             "casting {0} to {1} causes a loss of precision {2}({0} is {3} bits wide, but {1}'s mantissa \
951              is only {4} bits wide)",
952             cast_from,
953             if cast_to_f64 { "f64" } else { "f32" },
954             if arch_dependent { arch_dependent_str } else { "" },
955             from_nbits_str,
956             mantissa_nbits
957         ),
958     );
959 }
960
961 fn should_strip_parens(op: &Expr, snip: &str) -> bool {
962     if let ExprKind::Binary(_, _, _) = op.node {
963         if snip.starts_with('(') && snip.ends_with(')') {
964             return true;
965         }
966     }
967     false
968 }
969
970 fn span_lossless_lint(cx: &LateContext<'_, '_>, expr: &Expr, op: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
971     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
972     if in_constant(cx, expr.hir_id) {
973         return;
974     }
975     // The suggestion is to use a function call, so if the original expression
976     // has parens on the outside, they are no longer needed.
977     let mut applicability = Applicability::MachineApplicable;
978     let opt = snippet_opt(cx, op.span);
979     let sugg = if let Some(ref snip) = opt {
980         if should_strip_parens(op, snip) {
981             &snip[1..snip.len() - 1]
982         } else {
983             snip.as_str()
984         }
985     } else {
986         applicability = Applicability::HasPlaceholders;
987         ".."
988     };
989
990     span_lint_and_sugg(
991         cx,
992         CAST_LOSSLESS,
993         expr.span,
994         &format!(
995             "casting {} to {} may become silently lossy if types change",
996             cast_from, cast_to
997         ),
998         "try",
999         format!("{}::from({})", cast_to, sugg),
1000         applicability,
1001     );
1002 }
1003
1004 enum ArchSuffix {
1005     _32,
1006     _64,
1007     None,
1008 }
1009
1010 fn check_loss_of_sign(cx: &LateContext<'_, '_>, expr: &Expr, op: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
1011     if !cast_from.is_signed() || cast_to.is_signed() {
1012         return;
1013     }
1014
1015     // don't lint for positive constants
1016     let const_val = constant(cx, &cx.tables, op);
1017     if_chain! {
1018         if let Some((const_val, _)) = const_val;
1019         if let Constant::Int(n) = const_val;
1020         if let ty::Int(ity) = cast_from.sty;
1021         if sext(cx.tcx, n, ity) >= 0;
1022         then {
1023             return
1024         }
1025     }
1026
1027     span_lint(
1028         cx,
1029         CAST_SIGN_LOSS,
1030         expr.span,
1031         &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to),
1032     );
1033 }
1034
1035 fn check_truncation_and_wrapping(cx: &LateContext<'_, '_>, expr: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
1036     let arch_64_suffix = " on targets with 64-bit wide pointers";
1037     let arch_32_suffix = " on targets with 32-bit wide pointers";
1038     let cast_unsigned_to_signed = !cast_from.is_signed() && cast_to.is_signed();
1039     let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
1040     let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
1041     let (span_truncation, suffix_truncation, span_wrap, suffix_wrap) =
1042         match (is_isize_or_usize(cast_from), is_isize_or_usize(cast_to)) {
1043             (true, true) | (false, false) => (
1044                 to_nbits < from_nbits,
1045                 ArchSuffix::None,
1046                 to_nbits == from_nbits && cast_unsigned_to_signed,
1047                 ArchSuffix::None,
1048             ),
1049             (true, false) => (
1050                 to_nbits <= 32,
1051                 if to_nbits == 32 {
1052                     ArchSuffix::_64
1053                 } else {
1054                     ArchSuffix::None
1055                 },
1056                 to_nbits <= 32 && cast_unsigned_to_signed,
1057                 ArchSuffix::_32,
1058             ),
1059             (false, true) => (
1060                 from_nbits == 64,
1061                 ArchSuffix::_32,
1062                 cast_unsigned_to_signed,
1063                 if from_nbits == 64 {
1064                     ArchSuffix::_64
1065                 } else {
1066                     ArchSuffix::_32
1067                 },
1068             ),
1069         };
1070     if span_truncation {
1071         span_lint(
1072             cx,
1073             CAST_POSSIBLE_TRUNCATION,
1074             expr.span,
1075             &format!(
1076                 "casting {} to {} may truncate the value{}",
1077                 cast_from,
1078                 cast_to,
1079                 match suffix_truncation {
1080                     ArchSuffix::_32 => arch_32_suffix,
1081                     ArchSuffix::_64 => arch_64_suffix,
1082                     ArchSuffix::None => "",
1083                 }
1084             ),
1085         );
1086     }
1087     if span_wrap {
1088         span_lint(
1089             cx,
1090             CAST_POSSIBLE_WRAP,
1091             expr.span,
1092             &format!(
1093                 "casting {} to {} may wrap around the value{}",
1094                 cast_from,
1095                 cast_to,
1096                 match suffix_wrap {
1097                     ArchSuffix::_32 => arch_32_suffix,
1098                     ArchSuffix::_64 => arch_64_suffix,
1099                     ArchSuffix::None => "",
1100                 }
1101             ),
1102         );
1103     }
1104 }
1105
1106 fn check_lossless(cx: &LateContext<'_, '_>, expr: &Expr, op: &Expr, cast_from: Ty<'_>, cast_to: Ty<'_>) {
1107     let cast_signed_to_unsigned = cast_from.is_signed() && !cast_to.is_signed();
1108     let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
1109     let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
1110     if !is_isize_or_usize(cast_from) && !is_isize_or_usize(cast_to) && from_nbits < to_nbits && !cast_signed_to_unsigned
1111     {
1112         span_lossless_lint(cx, expr, op, cast_from, cast_to);
1113     }
1114 }
1115
1116 impl LintPass for CastPass {
1117     fn get_lints(&self) -> LintArray {
1118         lint_array!(
1119             CAST_PRECISION_LOSS,
1120             CAST_SIGN_LOSS,
1121             CAST_POSSIBLE_TRUNCATION,
1122             CAST_POSSIBLE_WRAP,
1123             CAST_LOSSLESS,
1124             UNNECESSARY_CAST,
1125             CAST_PTR_ALIGNMENT,
1126             FN_TO_NUMERIC_CAST,
1127             FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
1128         )
1129     }
1130
1131     fn name(&self) -> &'static str {
1132         "Casts"
1133     }
1134 }
1135
1136 // Check if the given type is either `core::ffi::c_void` or
1137 // one of the platform specific `libc::<platform>::c_void` of libc.
1138 fn is_c_void(tcx: TyCtxt<'_, '_, '_>, ty: Ty<'_>) -> bool {
1139     if let ty::Adt(adt, _) = ty.sty {
1140         let mut apb = AbsolutePathBuffer { names: vec![] };
1141         tcx.push_item_path(&mut apb, adt.did, false);
1142
1143         if apb.names.is_empty() {
1144             return false;
1145         }
1146         if apb.names[0] == "libc" || apb.names[0] == "core" && *apb.names.last().unwrap() == "c_void" {
1147             return true;
1148         }
1149     }
1150     false
1151 }
1152
1153 /// Returns the mantissa bits wide of a fp type.
1154 /// Will return 0 if the type is not a fp
1155 fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
1156     match typ.sty {
1157         ty::Float(FloatTy::F32) => 23,
1158         ty::Float(FloatTy::F64) | ty::Infer(InferTy::FloatVar(_)) => 52,
1159         _ => 0,
1160     }
1161 }
1162
1163 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass {
1164     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1165         if let ExprKind::Cast(ref ex, _) = expr.node {
1166             let (cast_from, cast_to) = (cx.tables.expr_ty(ex), cx.tables.expr_ty(expr));
1167             lint_fn_to_numeric_cast(cx, expr, ex, cast_from, cast_to);
1168             if let ExprKind::Lit(ref lit) = ex.node {
1169                 use syntax::ast::{LitIntType, LitKind};
1170                 if let LitKind::Int(n, _) = lit.node {
1171                     if cast_to.is_fp() {
1172                         let from_nbits = 128 - n.leading_zeros();
1173                         let to_nbits = fp_ty_mantissa_nbits(cast_to);
1174                         if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits {
1175                             span_lint_and_sugg(
1176                                 cx,
1177                                 UNNECESSARY_CAST,
1178                                 expr.span,
1179                                 &format!("casting integer literal to {} is unnecessary", cast_to),
1180                                 "try",
1181                                 format!("{}_{}", n, cast_to),
1182                                 Applicability::MachineApplicable,
1183                             );
1184                             return;
1185                         }
1186                     }
1187                 }
1188                 match lit.node {
1189                     LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {},
1190                     _ => {
1191                         if cast_from.sty == cast_to.sty && !in_external_macro(cx.sess(), expr.span) {
1192                             span_lint(
1193                                 cx,
1194                                 UNNECESSARY_CAST,
1195                                 expr.span,
1196                                 &format!(
1197                                     "casting to the same type is unnecessary (`{}` -> `{}`)",
1198                                     cast_from, cast_to
1199                                 ),
1200                             );
1201                         }
1202                     },
1203                 }
1204             }
1205             if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx.sess(), expr.span) {
1206                 match (cast_from.is_integral(), cast_to.is_integral()) {
1207                     (true, false) => {
1208                         let from_nbits = int_ty_to_nbits(cast_from, cx.tcx);
1209                         let to_nbits = if let ty::Float(FloatTy::F32) = cast_to.sty {
1210                             32
1211                         } else {
1212                             64
1213                         };
1214                         if is_isize_or_usize(cast_from) || from_nbits >= to_nbits {
1215                             span_precision_loss_lint(cx, expr, cast_from, to_nbits == 64);
1216                         }
1217                         if from_nbits < to_nbits {
1218                             span_lossless_lint(cx, expr, ex, cast_from, cast_to);
1219                         }
1220                     },
1221                     (false, true) => {
1222                         span_lint(
1223                             cx,
1224                             CAST_POSSIBLE_TRUNCATION,
1225                             expr.span,
1226                             &format!("casting {} to {} may truncate the value", cast_from, cast_to),
1227                         );
1228                         if !cast_to.is_signed() {
1229                             span_lint(
1230                                 cx,
1231                                 CAST_SIGN_LOSS,
1232                                 expr.span,
1233                                 &format!("casting {} to {} may lose the sign of the value", cast_from, cast_to),
1234                             );
1235                         }
1236                     },
1237                     (true, true) => {
1238                         check_loss_of_sign(cx, expr, ex, cast_from, cast_to);
1239                         check_truncation_and_wrapping(cx, expr, cast_from, cast_to);
1240                         check_lossless(cx, expr, ex, cast_from, cast_to);
1241                     },
1242                     (false, false) => {
1243                         if let (&ty::Float(FloatTy::F64), &ty::Float(FloatTy::F32)) = (&cast_from.sty, &cast_to.sty) {
1244                             span_lint(
1245                                 cx,
1246                                 CAST_POSSIBLE_TRUNCATION,
1247                                 expr.span,
1248                                 "casting f64 to f32 may truncate the value",
1249                             );
1250                         }
1251                         if let (&ty::Float(FloatTy::F32), &ty::Float(FloatTy::F64)) = (&cast_from.sty, &cast_to.sty) {
1252                             span_lossless_lint(cx, expr, ex, cast_from, cast_to);
1253                         }
1254                     },
1255                 }
1256             }
1257
1258             if_chain! {
1259                 if let ty::RawPtr(from_ptr_ty) = &cast_from.sty;
1260                 if let ty::RawPtr(to_ptr_ty) = &cast_to.sty;
1261                 if let Some(from_align) = cx.layout_of(from_ptr_ty.ty).ok().map(|a| a.align.abi);
1262                 if let Some(to_align) = cx.layout_of(to_ptr_ty.ty).ok().map(|a| a.align.abi);
1263                 if from_align < to_align;
1264                 // with c_void, we inherently need to trust the user
1265                 if !is_c_void(cx.tcx, from_ptr_ty.ty);
1266                 then {
1267                     span_lint(
1268                         cx,
1269                         CAST_PTR_ALIGNMENT,
1270                         expr.span,
1271                         &format!("casting from `{}` to a more-strictly-aligned pointer (`{}`)", cast_from, cast_to)
1272                     );
1273                 }
1274             }
1275         }
1276     }
1277 }
1278
1279 fn lint_fn_to_numeric_cast(
1280     cx: &LateContext<'_, '_>,
1281     expr: &Expr,
1282     cast_expr: &Expr,
1283     cast_from: Ty<'_>,
1284     cast_to: Ty<'_>,
1285 ) {
1286     // We only want to check casts to `ty::Uint` or `ty::Int`
1287     match cast_to.sty {
1288         ty::Uint(_) | ty::Int(..) => { /* continue on */ },
1289         _ => return,
1290     }
1291     match cast_from.sty {
1292         ty::FnDef(..) | ty::FnPtr(_) => {
1293             let mut applicability = Applicability::MachineApplicable;
1294             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
1295
1296             let to_nbits = int_ty_to_nbits(cast_to, cx.tcx);
1297             if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
1298                 span_lint_and_sugg(
1299                     cx,
1300                     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
1301                     expr.span,
1302                     &format!(
1303                         "casting function pointer `{}` to `{}`, which truncates the value",
1304                         from_snippet, cast_to
1305                     ),
1306                     "try",
1307                     format!("{} as usize", from_snippet),
1308                     applicability,
1309                 );
1310             } else if cast_to.sty != ty::Uint(UintTy::Usize) {
1311                 span_lint_and_sugg(
1312                     cx,
1313                     FN_TO_NUMERIC_CAST,
1314                     expr.span,
1315                     &format!("casting function pointer `{}` to `{}`", from_snippet, cast_to),
1316                     "try",
1317                     format!("{} as usize", from_snippet),
1318                     applicability,
1319                 );
1320             }
1321         },
1322         _ => {},
1323     }
1324 }
1325
1326 declare_clippy_lint! {
1327     /// **What it does:** Checks for types used in structs, parameters and `let`
1328     /// declarations above a certain complexity threshold.
1329     ///
1330     /// **Why is this bad?** Too complex types make the code less readable. Consider
1331     /// using a `type` definition to simplify them.
1332     ///
1333     /// **Known problems:** None.
1334     ///
1335     /// **Example:**
1336     /// ```rust
1337     /// struct Foo {
1338     ///     inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>>,
1339     /// }
1340     /// ```
1341     pub TYPE_COMPLEXITY,
1342     complexity,
1343     "usage of very complex types that might be better factored into `type` definitions"
1344 }
1345
1346 pub struct TypeComplexityPass {
1347     threshold: u64,
1348 }
1349
1350 impl TypeComplexityPass {
1351     pub fn new(threshold: u64) -> Self {
1352         Self { threshold }
1353     }
1354 }
1355
1356 impl LintPass for TypeComplexityPass {
1357     fn get_lints(&self) -> LintArray {
1358         lint_array!(TYPE_COMPLEXITY)
1359     }
1360
1361     fn name(&self) -> &'static str {
1362         "TypeComplexityPass"
1363     }
1364 }
1365
1366 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass {
1367     fn check_fn(
1368         &mut self,
1369         cx: &LateContext<'a, 'tcx>,
1370         _: FnKind<'tcx>,
1371         decl: &'tcx FnDecl,
1372         _: &'tcx Body,
1373         _: Span,
1374         _: HirId,
1375     ) {
1376         self.check_fndecl(cx, decl);
1377     }
1378
1379     fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) {
1380         // enum variants are also struct fields now
1381         self.check_type(cx, &field.ty);
1382     }
1383
1384     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
1385         match item.node {
1386             ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_type(cx, ty),
1387             // functions, enums, structs, impls and traits are covered
1388             _ => (),
1389         }
1390     }
1391
1392     fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
1393         match item.node {
1394             TraitItemKind::Const(ref ty, _) | TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty),
1395             TraitItemKind::Method(MethodSig { ref decl, .. }, TraitMethod::Required(_)) => self.check_fndecl(cx, decl),
1396             // methods with default impl are covered by check_fn
1397             _ => (),
1398         }
1399     }
1400
1401     fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) {
1402         match item.node {
1403             ImplItemKind::Const(ref ty, _) | ImplItemKind::Type(ref ty) => self.check_type(cx, ty),
1404             // methods are covered by check_fn
1405             _ => (),
1406         }
1407     }
1408
1409     fn check_local(&mut self, cx: &LateContext<'a, 'tcx>, local: &'tcx Local) {
1410         if let Some(ref ty) = local.ty {
1411             self.check_type(cx, ty);
1412         }
1413     }
1414 }
1415
1416 impl<'a, 'tcx> TypeComplexityPass {
1417     fn check_fndecl(&self, cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl) {
1418         for arg in &decl.inputs {
1419             self.check_type(cx, arg);
1420         }
1421         if let Return(ref ty) = decl.output {
1422             self.check_type(cx, ty);
1423         }
1424     }
1425
1426     fn check_type(&self, cx: &LateContext<'_, '_>, ty: &hir::Ty) {
1427         if in_macro(ty.span) {
1428             return;
1429         }
1430         let score = {
1431             let mut visitor = TypeComplexityVisitor { score: 0, nest: 1 };
1432             visitor.visit_ty(ty);
1433             visitor.score
1434         };
1435
1436         if score > self.threshold {
1437             span_lint(
1438                 cx,
1439                 TYPE_COMPLEXITY,
1440                 ty.span,
1441                 "very complex type used. Consider factoring parts into `type` definitions",
1442             );
1443         }
1444     }
1445 }
1446
1447 /// Walks a type and assigns a complexity score to it.
1448 struct TypeComplexityVisitor {
1449     /// total complexity score of the type
1450     score: u64,
1451     /// current nesting level
1452     nest: u64,
1453 }
1454
1455 impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
1456     fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
1457         let (add_score, sub_nest) = match ty.node {
1458             // _, &x and *x have only small overhead; don't mess with nesting level
1459             TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0),
1460
1461             // the "normal" components of a type: named types, arrays/tuples
1462             TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
1463
1464             // function types bring a lot of overhead
1465             TyKind::BareFn(ref bare) if bare.abi == Abi::Rust => (50 * self.nest, 1),
1466
1467             TyKind::TraitObject(ref param_bounds, _) => {
1468                 let has_lifetime_parameters = param_bounds.iter().any(|bound| {
1469                     bound.bound_generic_params.iter().any(|gen| match gen.kind {
1470                         GenericParamKind::Lifetime { .. } => true,
1471                         _ => false,
1472                     })
1473                 });
1474                 if has_lifetime_parameters {
1475                     // complex trait bounds like A<'a, 'b>
1476                     (50 * self.nest, 1)
1477                 } else {
1478                     // simple trait bounds like A + B
1479                     (20 * self.nest, 0)
1480                 }
1481             },
1482
1483             _ => (0, 0),
1484         };
1485         self.score += add_score;
1486         self.nest += sub_nest;
1487         walk_ty(self, ty);
1488         self.nest -= sub_nest;
1489     }
1490     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
1491         NestedVisitorMap::None
1492     }
1493 }
1494
1495 declare_clippy_lint! {
1496     /// **What it does:** Checks for expressions where a character literal is cast
1497     /// to `u8` and suggests using a byte literal instead.
1498     ///
1499     /// **Why is this bad?** In general, casting values to smaller types is
1500     /// error-prone and should be avoided where possible. In the particular case of
1501     /// converting a character literal to u8, it is easy to avoid by just using a
1502     /// byte literal instead. As an added bonus, `b'a'` is even slightly shorter
1503     /// than `'a' as u8`.
1504     ///
1505     /// **Known problems:** None.
1506     ///
1507     /// **Example:**
1508     /// ```rust
1509     /// 'x' as u8
1510     /// ```
1511     ///
1512     /// A better version, using the byte literal:
1513     ///
1514     /// ```rust
1515     /// b'x'
1516     /// ```
1517     pub CHAR_LIT_AS_U8,
1518     complexity,
1519     "casting a character literal to u8"
1520 }
1521
1522 pub struct CharLitAsU8;
1523
1524 impl LintPass for CharLitAsU8 {
1525     fn get_lints(&self) -> LintArray {
1526         lint_array!(CHAR_LIT_AS_U8)
1527     }
1528
1529     fn name(&self) -> &'static str {
1530         "CharLiteralAsU8"
1531     }
1532 }
1533
1534 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CharLitAsU8 {
1535     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1536         use syntax::ast::{LitKind, UintTy};
1537
1538         if let ExprKind::Cast(ref e, _) = expr.node {
1539             if let ExprKind::Lit(ref l) = e.node {
1540                 if let LitKind::Char(_) = l.node {
1541                     if ty::Uint(UintTy::U8) == cx.tables.expr_ty(expr).sty && !in_macro(expr.span) {
1542                         let msg = "casting character literal to u8. `char`s \
1543                                    are 4 bytes wide in rust, so casting to u8 \
1544                                    truncates them";
1545                         let help = format!(
1546                             "Consider using a byte literal instead:\nb{}",
1547                             snippet(cx, e.span, "'x'")
1548                         );
1549                         span_help_and_lint(cx, CHAR_LIT_AS_U8, expr.span, msg, &help);
1550                     }
1551                 }
1552             }
1553         }
1554     }
1555 }
1556
1557 declare_clippy_lint! {
1558     /// **What it does:** Checks for comparisons where one side of the relation is
1559     /// either the minimum or maximum value for its type and warns if it involves a
1560     /// case that is always true or always false. Only integer and boolean types are
1561     /// checked.
1562     ///
1563     /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
1564     /// that is is possible for `x` to be less than the minimum. Expressions like
1565     /// `max < x` are probably mistakes.
1566     ///
1567     /// **Known problems:** For `usize` the size of the current compile target will
1568     /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such
1569     /// a comparison to detect target pointer width will trigger this lint. One can
1570     /// use `mem::sizeof` and compare its value or conditional compilation
1571     /// attributes
1572     /// like `#[cfg(target_pointer_width = "64")] ..` instead.
1573     ///
1574     /// **Example:**
1575     ///
1576     /// ```rust
1577     /// let vec: Vec<isize> = vec![];
1578     /// if vec.len() <= 0 {}
1579     /// if 100 > std::i32::MAX {}
1580     /// ```
1581     pub ABSURD_EXTREME_COMPARISONS,
1582     correctness,
1583     "a comparison with a maximum or minimum value that is always true or false"
1584 }
1585
1586 pub struct AbsurdExtremeComparisons;
1587
1588 impl LintPass for AbsurdExtremeComparisons {
1589     fn get_lints(&self) -> LintArray {
1590         lint_array!(ABSURD_EXTREME_COMPARISONS)
1591     }
1592
1593     fn name(&self) -> &'static str {
1594         "AbsurdExtremeComparisons"
1595     }
1596 }
1597
1598 enum ExtremeType {
1599     Minimum,
1600     Maximum,
1601 }
1602
1603 struct ExtremeExpr<'a> {
1604     which: ExtremeType,
1605     expr: &'a Expr,
1606 }
1607
1608 enum AbsurdComparisonResult {
1609     AlwaysFalse,
1610     AlwaysTrue,
1611     InequalityImpossible,
1612 }
1613
1614 fn is_cast_between_fixed_and_target<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> bool {
1615     if let ExprKind::Cast(ref cast_exp, _) = expr.node {
1616         let precast_ty = cx.tables.expr_ty(cast_exp);
1617         let cast_ty = cx.tables.expr_ty(expr);
1618
1619         return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty);
1620     }
1621
1622     false
1623 }
1624
1625 fn detect_absurd_comparison<'a, 'tcx>(
1626     cx: &LateContext<'a, 'tcx>,
1627     op: BinOpKind,
1628     lhs: &'tcx Expr,
1629     rhs: &'tcx Expr,
1630 ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> {
1631     use crate::types::AbsurdComparisonResult::*;
1632     use crate::types::ExtremeType::*;
1633     use crate::utils::comparisons::*;
1634
1635     // absurd comparison only makes sense on primitive types
1636     // primitive types don't implement comparison operators with each other
1637     if cx.tables.expr_ty(lhs) != cx.tables.expr_ty(rhs) {
1638         return None;
1639     }
1640
1641     // comparisons between fix sized types and target sized types are considered unanalyzable
1642     if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) {
1643         return None;
1644     }
1645
1646     let normalized = normalize_comparison(op, lhs, rhs);
1647     let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
1648         val
1649     } else {
1650         return None;
1651     };
1652
1653     let lx = detect_extreme_expr(cx, normalized_lhs);
1654     let rx = detect_extreme_expr(cx, normalized_rhs);
1655
1656     Some(match rel {
1657         Rel::Lt => {
1658             match (lx, rx) {
1659                 (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, AlwaysFalse), // max < x
1660                 (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, AlwaysFalse), // x < min
1661                 _ => return None,
1662             }
1663         },
1664         Rel::Le => {
1665             match (lx, rx) {
1666                 (Some(l @ ExtremeExpr { which: Minimum, .. }), _) => (l, AlwaysTrue), // min <= x
1667                 (Some(l @ ExtremeExpr { which: Maximum, .. }), _) => (l, InequalityImpossible), // max <= x
1668                 (_, Some(r @ ExtremeExpr { which: Minimum, .. })) => (r, InequalityImpossible), // x <= min
1669                 (_, Some(r @ ExtremeExpr { which: Maximum, .. })) => (r, AlwaysTrue), // x <= max
1670                 _ => return None,
1671             }
1672         },
1673         Rel::Ne | Rel::Eq => return None,
1674     })
1675 }
1676
1677 fn detect_extreme_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Option<ExtremeExpr<'tcx>> {
1678     use crate::types::ExtremeType::*;
1679
1680     let ty = cx.tables.expr_ty(expr);
1681
1682     let cv = constant(cx, cx.tables, expr)?.0;
1683
1684     let which = match (&ty.sty, cv) {
1685         (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => Minimum,
1686         (&ty::Int(ity), Constant::Int(i))
1687             if i == unsext(cx.tcx, i128::min_value() >> (128 - int_bits(cx.tcx, ity)), ity) =>
1688         {
1689             Minimum
1690         },
1691
1692         (&ty::Bool, Constant::Bool(true)) => Maximum,
1693         (&ty::Int(ity), Constant::Int(i))
1694             if i == unsext(cx.tcx, i128::max_value() >> (128 - int_bits(cx.tcx, ity)), ity) =>
1695         {
1696             Maximum
1697         },
1698         (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::max_value(), uty) == i => Maximum,
1699
1700         _ => return None,
1701     };
1702     Some(ExtremeExpr { which, expr })
1703 }
1704
1705 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AbsurdExtremeComparisons {
1706     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1707         use crate::types::AbsurdComparisonResult::*;
1708         use crate::types::ExtremeType::*;
1709
1710         if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.node {
1711             if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) {
1712                 if !in_macro(expr.span) {
1713                     let msg = "this comparison involving the minimum or maximum element for this \
1714                                type contains a case that is always true or always false";
1715
1716                     let conclusion = match result {
1717                         AlwaysFalse => "this comparison is always false".to_owned(),
1718                         AlwaysTrue => "this comparison is always true".to_owned(),
1719                         InequalityImpossible => format!(
1720                             "the case where the two sides are not equal never occurs, consider using {} == {} \
1721                              instead",
1722                             snippet(cx, lhs.span, "lhs"),
1723                             snippet(cx, rhs.span, "rhs")
1724                         ),
1725                     };
1726
1727                     let help = format!(
1728                         "because {} is the {} value for this type, {}",
1729                         snippet(cx, culprit.expr.span, "x"),
1730                         match culprit.which {
1731                             Minimum => "minimum",
1732                             Maximum => "maximum",
1733                         },
1734                         conclusion
1735                     );
1736
1737                     span_help_and_lint(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, &help);
1738                 }
1739             }
1740         }
1741     }
1742 }
1743
1744 declare_clippy_lint! {
1745     /// **What it does:** Checks for comparisons where the relation is always either
1746     /// true or false, but where one side has been upcast so that the comparison is
1747     /// necessary. Only integer types are checked.
1748     ///
1749     /// **Why is this bad?** An expression like `let x : u8 = ...; (x as u32) > 300`
1750     /// will mistakenly imply that it is possible for `x` to be outside the range of
1751     /// `u8`.
1752     ///
1753     /// **Known problems:**
1754     /// https://github.com/rust-lang/rust-clippy/issues/886
1755     ///
1756     /// **Example:**
1757     /// ```rust
1758     /// let x : u8 = ...; (x as u32) > 300
1759     /// ```
1760     pub INVALID_UPCAST_COMPARISONS,
1761     pedantic,
1762     "a comparison involving an upcast which is always true or false"
1763 }
1764
1765 pub struct InvalidUpcastComparisons;
1766
1767 impl LintPass for InvalidUpcastComparisons {
1768     fn get_lints(&self) -> LintArray {
1769         lint_array!(INVALID_UPCAST_COMPARISONS)
1770     }
1771
1772     fn name(&self) -> &'static str {
1773         "InvalidUpcastComparisons"
1774     }
1775 }
1776
1777 #[derive(Copy, Clone, Debug, Eq)]
1778 enum FullInt {
1779     S(i128),
1780     U(u128),
1781 }
1782
1783 impl FullInt {
1784     #[allow(clippy::cast_sign_loss)]
1785     fn cmp_s_u(s: i128, u: u128) -> Ordering {
1786         if s < 0 {
1787             Ordering::Less
1788         } else if u > (i128::max_value() as u128) {
1789             Ordering::Greater
1790         } else {
1791             (s as u128).cmp(&u)
1792         }
1793     }
1794 }
1795
1796 impl PartialEq for FullInt {
1797     fn eq(&self, other: &Self) -> bool {
1798         self.partial_cmp(other).expect("partial_cmp only returns Some(_)") == Ordering::Equal
1799     }
1800 }
1801
1802 impl PartialOrd for FullInt {
1803     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1804         Some(match (self, other) {
1805             (&FullInt::S(s), &FullInt::S(o)) => s.cmp(&o),
1806             (&FullInt::U(s), &FullInt::U(o)) => s.cmp(&o),
1807             (&FullInt::S(s), &FullInt::U(o)) => Self::cmp_s_u(s, o),
1808             (&FullInt::U(s), &FullInt::S(o)) => Self::cmp_s_u(o, s).reverse(),
1809         })
1810     }
1811 }
1812 impl Ord for FullInt {
1813     fn cmp(&self, other: &Self) -> Ordering {
1814         self.partial_cmp(other)
1815             .expect("partial_cmp for FullInt can never return None")
1816     }
1817 }
1818
1819 fn numeric_cast_precast_bounds<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr) -> Option<(FullInt, FullInt)> {
1820     use std::*;
1821     use syntax::ast::{IntTy, UintTy};
1822
1823     if let ExprKind::Cast(ref cast_exp, _) = expr.node {
1824         let pre_cast_ty = cx.tables.expr_ty(cast_exp);
1825         let cast_ty = cx.tables.expr_ty(expr);
1826         // if it's a cast from i32 to u32 wrapping will invalidate all these checks
1827         if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
1828             return None;
1829         }
1830         match pre_cast_ty.sty {
1831             ty::Int(int_ty) => Some(match int_ty {
1832                 IntTy::I8 => (
1833                     FullInt::S(i128::from(i8::min_value())),
1834                     FullInt::S(i128::from(i8::max_value())),
1835                 ),
1836                 IntTy::I16 => (
1837                     FullInt::S(i128::from(i16::min_value())),
1838                     FullInt::S(i128::from(i16::max_value())),
1839                 ),
1840                 IntTy::I32 => (
1841                     FullInt::S(i128::from(i32::min_value())),
1842                     FullInt::S(i128::from(i32::max_value())),
1843                 ),
1844                 IntTy::I64 => (
1845                     FullInt::S(i128::from(i64::min_value())),
1846                     FullInt::S(i128::from(i64::max_value())),
1847                 ),
1848                 IntTy::I128 => (FullInt::S(i128::min_value()), FullInt::S(i128::max_value())),
1849                 IntTy::Isize => (
1850                     FullInt::S(isize::min_value() as i128),
1851                     FullInt::S(isize::max_value() as i128),
1852                 ),
1853             }),
1854             ty::Uint(uint_ty) => Some(match uint_ty {
1855                 UintTy::U8 => (
1856                     FullInt::U(u128::from(u8::min_value())),
1857                     FullInt::U(u128::from(u8::max_value())),
1858                 ),
1859                 UintTy::U16 => (
1860                     FullInt::U(u128::from(u16::min_value())),
1861                     FullInt::U(u128::from(u16::max_value())),
1862                 ),
1863                 UintTy::U32 => (
1864                     FullInt::U(u128::from(u32::min_value())),
1865                     FullInt::U(u128::from(u32::max_value())),
1866                 ),
1867                 UintTy::U64 => (
1868                     FullInt::U(u128::from(u64::min_value())),
1869                     FullInt::U(u128::from(u64::max_value())),
1870                 ),
1871                 UintTy::U128 => (FullInt::U(u128::min_value()), FullInt::U(u128::max_value())),
1872                 UintTy::Usize => (
1873                     FullInt::U(usize::min_value() as u128),
1874                     FullInt::U(usize::max_value() as u128),
1875                 ),
1876             }),
1877             _ => None,
1878         }
1879     } else {
1880         None
1881     }
1882 }
1883
1884 fn node_as_const_fullint<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Option<FullInt> {
1885     let val = constant(cx, cx.tables, expr)?.0;
1886     if let Constant::Int(const_int) = val {
1887         match cx.tables.expr_ty(expr).sty {
1888             ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
1889             ty::Uint(_) => Some(FullInt::U(const_int)),
1890             _ => None,
1891         }
1892     } else {
1893         None
1894     }
1895 }
1896
1897 fn err_upcast_comparison(cx: &LateContext<'_, '_>, span: Span, expr: &Expr, always: bool) {
1898     if let ExprKind::Cast(ref cast_val, _) = expr.node {
1899         span_lint(
1900             cx,
1901             INVALID_UPCAST_COMPARISONS,
1902             span,
1903             &format!(
1904                 "because of the numeric bounds on `{}` prior to casting, this expression is always {}",
1905                 snippet(cx, cast_val.span, "the expression"),
1906                 if always { "true" } else { "false" },
1907             ),
1908         );
1909     }
1910 }
1911
1912 fn upcast_comparison_bounds_err<'a, 'tcx>(
1913     cx: &LateContext<'a, 'tcx>,
1914     span: Span,
1915     rel: comparisons::Rel,
1916     lhs_bounds: Option<(FullInt, FullInt)>,
1917     lhs: &'tcx Expr,
1918     rhs: &'tcx Expr,
1919     invert: bool,
1920 ) {
1921     use crate::utils::comparisons::*;
1922
1923     if let Some((lb, ub)) = lhs_bounds {
1924         if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
1925             if rel == Rel::Eq || rel == Rel::Ne {
1926                 if norm_rhs_val < lb || norm_rhs_val > ub {
1927                     err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
1928                 }
1929             } else if match rel {
1930                 Rel::Lt => {
1931                     if invert {
1932                         norm_rhs_val < lb
1933                     } else {
1934                         ub < norm_rhs_val
1935                     }
1936                 },
1937                 Rel::Le => {
1938                     if invert {
1939                         norm_rhs_val <= lb
1940                     } else {
1941                         ub <= norm_rhs_val
1942                     }
1943                 },
1944                 Rel::Eq | Rel::Ne => unreachable!(),
1945             } {
1946                 err_upcast_comparison(cx, span, lhs, true)
1947             } else if match rel {
1948                 Rel::Lt => {
1949                     if invert {
1950                         norm_rhs_val >= ub
1951                     } else {
1952                         lb >= norm_rhs_val
1953                     }
1954                 },
1955                 Rel::Le => {
1956                     if invert {
1957                         norm_rhs_val > ub
1958                     } else {
1959                         lb > norm_rhs_val
1960                     }
1961                 },
1962                 Rel::Eq | Rel::Ne => unreachable!(),
1963             } {
1964                 err_upcast_comparison(cx, span, lhs, false)
1965             }
1966         }
1967     }
1968 }
1969
1970 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidUpcastComparisons {
1971     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
1972         if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.node {
1973             let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs);
1974             let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized {
1975                 val
1976             } else {
1977                 return;
1978             };
1979
1980             let lhs_bounds = numeric_cast_precast_bounds(cx, normalized_lhs);
1981             let rhs_bounds = numeric_cast_precast_bounds(cx, normalized_rhs);
1982
1983             upcast_comparison_bounds_err(cx, expr.span, rel, lhs_bounds, normalized_lhs, normalized_rhs, false);
1984             upcast_comparison_bounds_err(cx, expr.span, rel, rhs_bounds, normalized_rhs, normalized_lhs, true);
1985         }
1986     }
1987 }
1988
1989 declare_clippy_lint! {
1990     /// **What it does:** Checks for public `impl` or `fn` missing generalization
1991     /// over different hashers and implicitly defaulting to the default hashing
1992     /// algorithm (SipHash).
1993     ///
1994     /// **Why is this bad?** `HashMap` or `HashSet` with custom hashers cannot be
1995     /// used with them.
1996     ///
1997     /// **Known problems:** Suggestions for replacing constructors can contain
1998     /// false-positives. Also applying suggestions can require modification of other
1999     /// pieces of code, possibly including external crates.
2000     ///
2001     /// **Example:**
2002     /// ```rust
2003     /// # use std::collections::HashMap;
2004     /// # use std::hash::Hash;
2005     /// # trait Serialize {};
2006     /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }
2007     ///
2008     /// pub fn foo(map: &mut HashMap<i32, i32>) { }
2009     /// ```
2010     pub IMPLICIT_HASHER,
2011     style,
2012     "missing generalization over different hashers"
2013 }
2014
2015 pub struct ImplicitHasher;
2016
2017 impl LintPass for ImplicitHasher {
2018     fn get_lints(&self) -> LintArray {
2019         lint_array!(IMPLICIT_HASHER)
2020     }
2021
2022     fn name(&self) -> &'static str {
2023         "ImplicitHasher"
2024     }
2025 }
2026
2027 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher {
2028     #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
2029     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
2030         use syntax_pos::BytePos;
2031
2032         fn suggestion<'a, 'tcx>(
2033             cx: &LateContext<'a, 'tcx>,
2034             db: &mut DiagnosticBuilder<'_>,
2035             generics_span: Span,
2036             generics_suggestion_span: Span,
2037             target: &ImplicitHasherType<'_>,
2038             vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
2039         ) {
2040             let generics_snip = snippet(cx, generics_span, "");
2041             // trim `<` `>`
2042             let generics_snip = if generics_snip.is_empty() {
2043                 ""
2044             } else {
2045                 &generics_snip[1..generics_snip.len() - 1]
2046             };
2047
2048             multispan_sugg(
2049                 db,
2050                 "consider adding a type parameter".to_string(),
2051                 vec![
2052                     (
2053                         generics_suggestion_span,
2054                         format!(
2055                             "<{}{}S: ::std::hash::BuildHasher{}>",
2056                             generics_snip,
2057                             if generics_snip.is_empty() { "" } else { ", " },
2058                             if vis.suggestions.is_empty() {
2059                                 ""
2060                             } else {
2061                                 // request users to add `Default` bound so that generic constructors can be used
2062                                 " + Default"
2063                             },
2064                         ),
2065                     ),
2066                     (
2067                         target.span(),
2068                         format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
2069                     ),
2070                 ],
2071             );
2072
2073             if !vis.suggestions.is_empty() {
2074                 multispan_sugg(db, "...and use generic constructor".into(), vis.suggestions);
2075             }
2076         }
2077
2078         if !cx.access_levels.is_exported(cx.tcx.hir().hir_to_node_id(item.hir_id)) {
2079             return;
2080         }
2081
2082         match item.node {
2083             ItemKind::Impl(_, _, _, ref generics, _, ref ty, ref items) => {
2084                 let mut vis = ImplicitHasherTypeVisitor::new(cx);
2085                 vis.visit_ty(ty);
2086
2087                 for target in &vis.found {
2088                     if differing_macro_contexts(item.span, target.span()) {
2089                         return;
2090                     }
2091
2092                     let generics_suggestion_span = generics.span.substitute_dummy({
2093                         let pos = snippet_opt(cx, item.span.until(target.span()))
2094                             .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
2095                         if let Some(pos) = pos {
2096                             Span::new(pos, pos, item.span.data().ctxt)
2097                         } else {
2098                             return;
2099                         }
2100                     });
2101
2102                     let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
2103                     for item in items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
2104                         ctr_vis.visit_impl_item(item);
2105                     }
2106
2107                     span_lint_and_then(
2108                         cx,
2109                         IMPLICIT_HASHER,
2110                         target.span(),
2111                         &format!(
2112                             "impl for `{}` should be generalized over different hashers",
2113                             target.type_name()
2114                         ),
2115                         move |db| {
2116                             suggestion(cx, db, generics.span, generics_suggestion_span, target, ctr_vis);
2117                         },
2118                     );
2119                 }
2120             },
2121             ItemKind::Fn(ref decl, .., ref generics, body_id) => {
2122                 let body = cx.tcx.hir().body(body_id);
2123
2124                 for ty in &decl.inputs {
2125                     let mut vis = ImplicitHasherTypeVisitor::new(cx);
2126                     vis.visit_ty(ty);
2127
2128                     for target in &vis.found {
2129                         let generics_suggestion_span = generics.span.substitute_dummy({
2130                             let pos = snippet_opt(cx, item.span.until(body.arguments[0].pat.span))
2131                                 .and_then(|snip| {
2132                                     let i = snip.find("fn")?;
2133                                     Some(item.span.lo() + BytePos((i + (&snip[i..]).find('(')?) as u32))
2134                                 })
2135                                 .expect("failed to create span for type parameters");
2136                             Span::new(pos, pos, item.span.data().ctxt)
2137                         });
2138
2139                         let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
2140                         ctr_vis.visit_body(body);
2141
2142                         span_lint_and_then(
2143                             cx,
2144                             IMPLICIT_HASHER,
2145                             target.span(),
2146                             &format!(
2147                                 "parameter of type `{}` should be generalized over different hashers",
2148                                 target.type_name()
2149                             ),
2150                             move |db| {
2151                                 suggestion(cx, db, generics.span, generics_suggestion_span, target, ctr_vis);
2152                             },
2153                         );
2154                     }
2155                 }
2156             },
2157             _ => {},
2158         }
2159     }
2160 }
2161
2162 enum ImplicitHasherType<'tcx> {
2163     HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
2164     HashSet(Span, Ty<'tcx>, Cow<'static, str>),
2165 }
2166
2167 impl<'tcx> ImplicitHasherType<'tcx> {
2168     /// Checks that `ty` is a target type without a BuildHasher.
2169     fn new<'a>(cx: &LateContext<'a, 'tcx>, hir_ty: &hir::Ty) -> Option<Self> {
2170         if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.node {
2171             let params: Vec<_> = path
2172                 .segments
2173                 .last()
2174                 .as_ref()?
2175                 .args
2176                 .as_ref()?
2177                 .args
2178                 .iter()
2179                 .filter_map(|arg| match arg {
2180                     GenericArg::Type(ty) => Some(ty),
2181                     _ => None,
2182                 })
2183                 .collect();
2184             let params_len = params.len();
2185
2186             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
2187
2188             if match_path(path, &paths::HASHMAP) && params_len == 2 {
2189                 Some(ImplicitHasherType::HashMap(
2190                     hir_ty.span,
2191                     ty,
2192                     snippet(cx, params[0].span, "K"),
2193                     snippet(cx, params[1].span, "V"),
2194                 ))
2195             } else if match_path(path, &paths::HASHSET) && params_len == 1 {
2196                 Some(ImplicitHasherType::HashSet(
2197                     hir_ty.span,
2198                     ty,
2199                     snippet(cx, params[0].span, "T"),
2200                 ))
2201             } else {
2202                 None
2203             }
2204         } else {
2205             None
2206         }
2207     }
2208
2209     fn type_name(&self) -> &'static str {
2210         match *self {
2211             ImplicitHasherType::HashMap(..) => "HashMap",
2212             ImplicitHasherType::HashSet(..) => "HashSet",
2213         }
2214     }
2215
2216     fn type_arguments(&self) -> String {
2217         match *self {
2218             ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
2219             ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
2220         }
2221     }
2222
2223     fn ty(&self) -> Ty<'tcx> {
2224         match *self {
2225             ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
2226         }
2227     }
2228
2229     fn span(&self) -> Span {
2230         match *self {
2231             ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
2232         }
2233     }
2234 }
2235
2236 struct ImplicitHasherTypeVisitor<'a, 'tcx: 'a> {
2237     cx: &'a LateContext<'a, 'tcx>,
2238     found: Vec<ImplicitHasherType<'tcx>>,
2239 }
2240
2241 impl<'a, 'tcx: 'a> ImplicitHasherTypeVisitor<'a, 'tcx> {
2242     fn new(cx: &'a LateContext<'a, 'tcx>) -> Self {
2243         Self { cx, found: vec![] }
2244     }
2245 }
2246
2247 impl<'a, 'tcx: 'a> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
2248     fn visit_ty(&mut self, t: &'tcx hir::Ty) {
2249         if let Some(target) = ImplicitHasherType::new(self.cx, t) {
2250             self.found.push(target);
2251         }
2252
2253         walk_ty(self, t);
2254     }
2255
2256     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
2257         NestedVisitorMap::None
2258     }
2259 }
2260
2261 /// Looks for default-hasher-dependent constructors like `HashMap::new`.
2262 struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx: 'a + 'b> {
2263     cx: &'a LateContext<'a, 'tcx>,
2264     body: &'a TypeckTables<'tcx>,
2265     target: &'b ImplicitHasherType<'tcx>,
2266     suggestions: BTreeMap<Span, String>,
2267 }
2268
2269 impl<'a, 'b, 'tcx: 'a + 'b> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
2270     fn new(cx: &'a LateContext<'a, 'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
2271         Self {
2272             cx,
2273             body: cx.tables,
2274             target,
2275             suggestions: BTreeMap::new(),
2276         }
2277     }
2278 }
2279
2280 impl<'a, 'b, 'tcx: 'a + 'b> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
2281     fn visit_body(&mut self, body: &'tcx Body) {
2282         let prev_body = self.body;
2283         self.body = self.cx.tcx.body_tables(body.id());
2284         walk_body(self, body);
2285         self.body = prev_body;
2286     }
2287
2288     fn visit_expr(&mut self, e: &'tcx Expr) {
2289         if_chain! {
2290             if let ExprKind::Call(ref fun, ref args) = e.node;
2291             if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.node;
2292             if let TyKind::Path(QPath::Resolved(None, ref ty_path)) = ty.node;
2293             then {
2294                 if !same_tys(self.cx, self.target.ty(), self.body.expr_ty(e)) {
2295                     return;
2296                 }
2297
2298                 if match_path(ty_path, &paths::HASHMAP) {
2299                     if method.ident.name == "new" {
2300                         self.suggestions
2301                             .insert(e.span, "HashMap::default()".to_string());
2302                     } else if method.ident.name == "with_capacity" {
2303                         self.suggestions.insert(
2304                             e.span,
2305                             format!(
2306                                 "HashMap::with_capacity_and_hasher({}, Default::default())",
2307                                 snippet(self.cx, args[0].span, "capacity"),
2308                             ),
2309                         );
2310                     }
2311                 } else if match_path(ty_path, &paths::HASHSET) {
2312                     if method.ident.name == "new" {
2313                         self.suggestions
2314                             .insert(e.span, "HashSet::default()".to_string());
2315                     } else if method.ident.name == "with_capacity" {
2316                         self.suggestions.insert(
2317                             e.span,
2318                             format!(
2319                                 "HashSet::with_capacity_and_hasher({}, Default::default())",
2320                                 snippet(self.cx, args[0].span, "capacity"),
2321                             ),
2322                         );
2323                     }
2324                 }
2325             }
2326         }
2327
2328         walk_expr(self, e);
2329     }
2330
2331     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
2332         NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir())
2333     }
2334 }
2335
2336 declare_clippy_lint! {
2337     /// **What it does:** Checks for casts of `&T` to `&mut T` anywhere in the code.
2338     ///
2339     /// **Why is this bad?** It’s basically guaranteed to be undefined behaviour.
2340     /// `UnsafeCell` is the only way to obtain aliasable data that is considered
2341     /// mutable.
2342     ///
2343     /// **Known problems:** None.
2344     ///
2345     /// **Example:**
2346     /// ```rust,ignore
2347     /// fn x(r: &i32) {
2348     ///     unsafe {
2349     ///         *(r as *const _ as *mut _) += 1;
2350     ///     }
2351     /// }
2352     /// ```
2353     ///
2354     /// Instead consider using interior mutability types.
2355     ///
2356     /// ```rust
2357     /// use std::cell::UnsafeCell;
2358     ///
2359     /// fn x(r: &UnsafeCell<i32>) {
2360     ///     unsafe {
2361     ///         *r.get() += 1;
2362     ///     }
2363     /// }
2364     /// ```
2365     pub CAST_REF_TO_MUT,
2366     correctness,
2367     "a cast of reference to a mutable pointer"
2368 }
2369
2370 pub struct RefToMut;
2371
2372 impl LintPass for RefToMut {
2373     fn get_lints(&self) -> LintArray {
2374         lint_array!(CAST_REF_TO_MUT)
2375     }
2376
2377     fn name(&self) -> &'static str {
2378         "RefToMut"
2379     }
2380 }
2381
2382 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RefToMut {
2383     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
2384         if_chain! {
2385             if let ExprKind::Unary(UnOp::UnDeref, e) = &expr.node;
2386             if let ExprKind::Cast(e, t) = &e.node;
2387             if let TyKind::Ptr(MutTy { mutbl: Mutability::MutMutable, .. }) = t.node;
2388             if let ExprKind::Cast(e, t) = &e.node;
2389             if let TyKind::Ptr(MutTy { mutbl: Mutability::MutImmutable, .. }) = t.node;
2390             if let ty::Ref(..) = cx.tables.node_type(e.hir_id).sty;
2391             then {
2392                 span_lint(
2393                     cx,
2394                     CAST_REF_TO_MUT,
2395                     expr.span,
2396                     "casting &T to &mut T may cause undefined behaviour, consider instead using an UnsafeCell",
2397                 );
2398             }
2399         }
2400     }
2401 }