submodules: update clippy from c0dbd34 to 7b2a7a2

matthiaskrgr · matthiaskrgr · commit 4b45e7357b57 · 2019-06-13T08:25:08.000+02:00
Changes: ```` Fix wrong lifetime of TyCtxt travis: Wait at most 30 minutes for base test Typos and minor grammar corrections Adds lint for integer division redundant_closure_for_method_calls fixes: lint does not trigger when there is a difference in mutability lint does not trigger when the method belongs to a trait which is not implemebted directly (Deref) Fix implicit_return docs rustup https://github.com/rust-lang/rust/pull/61758/files Remove wrong lifetime from LintContext Workaround for rust-lang/rustfmt#3615 Fixing eta with respect to lazy evaluation. ````
diff --git a/.travis.yml b/.travis.yml
@@ -98,7 +98,7 @@ script:
       export LD_LIBRARY_PATH=$(rustc --print sysroot)/lib
   - |
     if [ -z ${INTEGRATION} ]; then
-      ./ci/base-tests.sh && sleep 5
+      travis_wait 30 ./ci/base-tests.sh && sleep 5
     else
       ./ci/integration-tests.sh && sleep 5
     fi
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -956,6 +956,7 @@ All notable changes to this project will be documented in this file.
 [`inline_fn_without_body`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_fn_without_body
 [`int_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#int_plus_one
 [`integer_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_arithmetic
+[`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
 [`into_iter_on_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_array
 [`into_iter_on_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_ref
 [`invalid_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_ref
diff --git a/README.md b/README.md
@@ -7,7 +7,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are 304 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are 305 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you:
 
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
@@ -134,7 +134,7 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `allow`/`warn`/`deny`/`forbid` attributes with scoped clippy
-    /// lints and if those lints exist in clippy. If there is a uppercase letter in the lint name
+    /// lints and if those lints exist in clippy. If there is an uppercase letter in the lint name
     /// (not the tool name) and a lowercase version of this lint exists, it will suggest to lowercase
     /// the lint name.
     ///
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
@@ -74,7 +74,8 @@ impl CognitiveComplexity {
         let ret_adjust = if match_type(cx, ret_ty, &paths::RESULT) {
             returns
         } else {
-            returns / 2
+            #[allow(clippy::integer_division)]
+            (returns / 2)
         };
 
         if cc + divergence < match_arms + short_circuits {
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
@@ -121,7 +121,7 @@ impl Hash for Constant {
 }
 
 impl Constant {
-    pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
+    pub fn partial_cmp(tcx: TyCtxt<'_, '_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
         match (left, right) {
             (&Constant::Str(ref ls), &Constant::Str(ref rs)) => Some(ls.cmp(rs)),
             (&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)),
diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs
@@ -9,7 +9,7 @@ use syntax::source_map::Span;
 use crate::utils::{snippet_with_applicability, span_lint_and_sugg, SpanlessEq};
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for double comparions that could be simplified to a single expression.
+    /// **What it does:** Checks for double comparisons that could be simplified to a single expression.
     ///
     ///
     /// **Why is this bad?** Readability.
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
@@ -6,7 +6,9 @@ use rustc::ty::{self, Ty};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
 
-use crate::utils::{is_adjusted, iter_input_pats, snippet_opt, span_lint_and_then, type_is_unsafe_function};
+use crate::utils::{
+    implements_trait, is_adjusted, iter_input_pats, snippet_opt, span_lint_and_then, type_is_unsafe_function,
+};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for closures which just call another function where
@@ -82,6 +84,8 @@ fn check_closure(cx: &LateContext<'_, '_>, expr: &Expr) {
         if_chain!(
             if let ExprKind::Call(ref caller, ref args) = ex.node;
 
+            if let ExprKind::Path(_) = caller.node;
+
             // Not the same number of arguments, there is no way the closure is the same as the function return;
             if args.len() == decl.inputs.len();
 
@@ -150,7 +154,9 @@ fn get_ufcs_type_name(
     let actual_type_of_self = &cx.tables.node_type(self_arg.hir_id);
 
     if let Some(trait_id) = cx.tcx.trait_of_item(method_def_id) {
-        if match_borrow_depth(expected_type_of_self, &actual_type_of_self) {
+        if match_borrow_depth(expected_type_of_self, &actual_type_of_self)
+            && implements_trait(cx, actual_type_of_self, trait_id, &[])
+        {
             return Some(cx.tcx.def_path_str(trait_id));
         }
     }
@@ -166,7 +172,7 @@ fn get_ufcs_type_name(
 
 fn match_borrow_depth(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
     match (&lhs.sty, &rhs.sty) {
-        (ty::Ref(_, t1, _), ty::Ref(_, t2, _)) => match_borrow_depth(&t1, &t2),
+        (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_borrow_depth(&t1, &t2),
         (l, r) => match (l, r) {
             (ty::Ref(_, _, _), _) | (_, ty::Ref(_, _, _)) => false,
             (_, _) => true,
@@ -181,9 +187,8 @@ fn match_types(lhs: Ty<'_>, rhs: Ty<'_>) -> bool {
         | (ty::Int(_), ty::Int(_))
         | (ty::Uint(_), ty::Uint(_))
         | (ty::Str, ty::Str) => true,
-        (ty::Ref(_, t1, _), ty::Ref(_, t2, _))
-        | (ty::Array(t1, _), ty::Array(t2, _))
-        | (ty::Slice(t1), ty::Slice(t2)) => match_types(t1, t2),
+        (ty::Ref(_, t1, mut1), ty::Ref(_, t2, mut2)) => mut1 == mut2 && match_types(t1, t2),
+        (ty::Array(t1, _), ty::Array(t2, _)) | (ty::Slice(t1), ty::Slice(t2)) => match_types(t1, t2),
         (ty::Adt(def1, _), ty::Adt(def2, _)) => def1 == def2,
         (_, _) => false,
     }
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
@@ -92,7 +92,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessFormat {
     }
 }
 
-fn span_useless_format<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, span: Span, help: &str, mut sugg: String) {
+fn span_useless_format<T: LintContext>(cx: &T, span: Span, help: &str, mut sugg: String) {
     let to_replace = span.source_callsite();
 
     // The callsite span contains the statement semicolon for some reason.
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
@@ -56,7 +56,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for public functions that dereferences raw pointer
+    /// **What it does:** Checks for public functions that dereference raw pointer
     /// arguments but are not marked unsafe.
     ///
     /// **Why is this bad?** The function should probably be marked `unsafe`, since
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
@@ -18,13 +18,13 @@ declare_clippy_lint! {
     ///
     /// **Example:**
     /// ```rust
-    /// fn foo(x: usize) {
+    /// fn foo(x: usize) -> usize {
     ///     x
     /// }
     /// ```
     /// add return
     /// ```rust
-    /// fn foo(x: usize) {
+    /// fn foo(x: usize) -> usize {
     ///     return x;
     /// }
     /// ```
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
@@ -37,7 +37,7 @@ declare_clippy_lint! {
 }
 
 declare_clippy_lint! {
-    /// **What it does:** Checks for usage of indexing or slicing. Arrays are special cased, this lint
+    /// **What it does:** Checks for usage of indexing or slicing. Arrays are special cases, this lint
     /// does report on arrays if we can tell that slicing operations are in bounds and does not
     /// lint on constant `usize` indexing on arrays because that is handled by rustc's `const_err` lint.
     ///
diff --git a/clippy_lints/src/integer_division.rs b/clippy_lints/src/integer_division.rs
@@ -0,0 +1,55 @@
+use crate::utils::span_help_and_lint;
+use if_chain::if_chain;
+use rustc::hir;
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for division of integers
+    ///
+    /// **Why is this bad?** When outside of some very specific algorithms,
+    /// integer division is very often a mistake because it discards the
+    /// remainder.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// fn main() {
+    ///     let x = 3 / 2;
+    ///     println!("{}", x);
+    /// }
+    /// ```
+    pub INTEGER_DIVISION,
+    pedantic,
+    "integer division may cause loss of precision"
+}
+
+declare_lint_pass!(IntegerDivision => [INTEGER_DIVISION]);
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IntegerDivision {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
+        if is_integer_division(cx, expr) {
+            span_help_and_lint(
+                cx,
+                INTEGER_DIVISION,
+                expr.span,
+                "integer division",
+                "division of integers may cause loss of precision. consider using floats.",
+            );
+        }
+    }
+}
+
+fn is_integer_division<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) -> bool {
+    if_chain! {
+        if let hir::ExprKind::Binary(binop, left, right) = &expr.node;
+        if let hir::BinOpKind::Div = &binop.node;
+        then {
+            let (left_ty, right_ty) = (cx.tables.expr_ty(left), cx.tables.expr_ty(right));
+            return left_ty.is_integral() && right_ty.is_integral();
+        }
+    }
+
+    false
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -197,6 +197,7 @@ pub mod infinite_iter;
 pub mod inherent_impl;
 pub mod inline_fn_without_body;
 pub mod int_plus_one;
+pub mod integer_division;
 pub mod invalid_ref;
 pub mod items_after_statements;
 pub mod large_enum_variant;
@@ -580,6 +581,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
     reg.register_late_lint_pass(box transmuting_null::TransmutingNull);
     reg.register_late_lint_pass(box path_buf_push_overwrite::PathBufPushOverwrite);
     reg.register_late_lint_pass(box checked_conversions::CheckedConversions);
+    reg.register_late_lint_pass(box integer_division::IntegerDivision);
 
     reg.register_lint_group("clippy::restriction", Some("clippy_restriction"), vec![
         arithmetic::FLOAT_ARITHMETIC,
@@ -624,6 +626,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
         functions::TOO_MANY_LINES,
         if_not_else::IF_NOT_ELSE,
         infinite_iter::MAYBE_INFINITE_ITER,
+        integer_division::INTEGER_DIVISION,
         items_after_statements::ITEMS_AFTER_STATEMENTS,
         literal_representation::LARGE_DIGIT_GROUPS,
         loops::EXPLICIT_INTO_ITER_LOOP,
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
@@ -19,7 +19,7 @@ declare_clippy_lint! {
     /// **Why is this bad?** Redundant code.
     ///
     /// **Known problems:** Maybe false positives: Sometimes, the two branches are
-    /// painstakingly documented (which we of course do not detect), so they *may*
+    /// painstakingly documented (which we, of course, do not detect), so they *may*
     /// have some value. Even then, the documentation can be rewritten to match the
     /// shorter code.
     ///
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
@@ -12,7 +12,7 @@ use rustc::ty::{Ty, TypeFlags};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use rustc_errors::Applicability;
 use rustc_typeck::hir_ty_to_ty;
-use syntax_pos::{Span, DUMMY_SP};
+use syntax_pos::{InnerSpan, Span, DUMMY_SP};
 
 use crate::utils::{in_constant, in_macro_or_desugar, is_copy, span_lint_and_then};
 
@@ -123,7 +123,7 @@ fn verify_ty_bound<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, source: S
         }
         match source {
             Source::Item { .. } => {
-                let const_kw_span = span.from_inner_byte_pos(0, 5);
+                let const_kw_span = span.from_inner(InnerSpan::new(0, 5));
                 db.span_suggestion(
                     const_kw_span,
                     "make this a static item",
diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs
@@ -64,6 +64,7 @@ impl<'a, 'tcx> TriviallyCopyPassByRef {
             // Cap the calculated bit width at 32-bits to reduce
             // portability problems between 32 and 64-bit targets
             let bit_width = cmp::min(bit_width, 32);
+            #[allow(clippy::integer_division)]
             let byte_width = bit_width / 8;
             // Use a limit of 2 times the register byte width
             byte_width * 2
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
@@ -860,7 +860,7 @@ declare_clippy_lint! {
 
 /// Returns the size in bits of an integral type.
 /// Will return 0 if the type is not an int or uint variant
-fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_, '_, '_>) -> u64 {
+fn int_ty_to_nbits(typ: Ty<'_>, tcx: TyCtxt<'_, '_>) -> u64 {
     match typ.sty {
         ty::Int(i) => match i {
             IntTy::Isize => tcx.data_layout.pointer_size.bits(),
@@ -1120,7 +1120,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Casts {
             if let ExprKind::Lit(ref lit) = ex.node {
                 use syntax::ast::{LitIntType, LitKind};
                 if let LitKind::Int(n, _) = lit.node {
-                    if cast_to.is_fp() {
+                    if cast_to.is_floating_point() {
                         let from_nbits = 128 - n.leading_zeros();
                         let to_nbits = fp_ty_mantissa_nbits(cast_to);
                         if from_nbits != 0 && to_nbits != 0 && from_nbits <= to_nbits {
@@ -1495,7 +1495,7 @@ declare_clippy_lint! {
     /// checked.
     ///
     /// **Why is this bad?** An expression like `min <= x` may misleadingly imply
-    /// that is is possible for `x` to be less than the minimum. Expressions like
+    /// that it is possible for `x` to be less than the minimum. Expressions like
     /// `max < x` are probably mistakes.
     ///
     /// **Known problems:** For `usize` the size of the current compile target will
diff --git a/clippy_lints/src/utils/diagnostics.rs b/clippy_lints/src/utils/diagnostics.rs
@@ -48,7 +48,7 @@ impl<'a> DiagnosticWrapper<'a> {
 /// 17 |     std::mem::forget(seven);
 ///    |     ^^^^^^^^^^^^^^^^^^^^^^^
 /// ```
-pub fn span_lint<'a, T: LintContext<'a>>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: &str) {
+pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: &str) {
     DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg)).docs_link(lint);
 }
 
@@ -70,13 +70,7 @@ pub fn span_lint<'a, T: LintContext<'a>>(cx: &T, lint: &'static Lint, sp: impl I
 ///    |
 ///    = help: Consider using `std::f64::NAN` if you would like a constant representing NaN
 /// ```
-pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
-    cx: &'a T,
-    lint: &'static Lint,
-    span: Span,
-    msg: &str,
-    help: &str,
-) {
+pub fn span_help_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, help: &str) {
     let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg));
     db.0.help(help);
     db.docs_link(lint);
@@ -103,7 +97,7 @@ pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
 /// 10 |     forget(&SomeStruct);
 ///    |            ^^^^^^^^^^^
 /// ```
-pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
+pub fn span_note_and_lint<'a, T: LintContext>(
     cx: &'a T,
     lint: &'static Lint,
     span: Span,
@@ -120,13 +114,8 @@ pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(
     db.docs_link(lint);
 }
 
-pub fn span_lint_and_then<'a, 'tcx: 'a, T: LintContext<'tcx>, F>(
-    cx: &'a T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    f: F,
-) where
+pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F)
+where
     F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>),
 {
     let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg));
@@ -166,7 +155,7 @@ pub fn span_lint_hir_and_then(
 ///     |
 ///     = note: `-D fold-any` implied by `-D warnings`
 /// ```
-pub fn span_lint_and_sugg<'a, 'tcx: 'a, T: LintContext<'tcx>>(
+pub fn span_lint_and_sugg<'a, T: LintContext>(
     cx: &'a T,
     lint: &'static Lint,
     sp: Span,
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
diff --git a/tests/ui/integer_division.rs b/tests/ui/integer_division.rs
diff --git a/tests/ui/integer_division.stderr b/tests/ui/integer_division.stderr

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ impl Hash for Constant {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`impl Constant {`
`124`		`- pub fn partial_cmp(tcx: TyCtxt<'_, '_, '_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {`
	`124`	`+ pub fn partial_cmp(tcx: TyCtxt<'_, '_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {`
`125`	`125`	`match (left, right) {`
`126`	`126`	`(&Constant::Str(ref ls), &Constant::Str(ref rs)) => Some(ls.cmp(rs)),`
`127`	`127`	`(&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)),`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessFormat {`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`		`-fn span_useless_format<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, span: Span, help: &str, mut sugg: String) {`
	`95`	`+fn span_useless_format<T: LintContext>(cx: &T, span: Span, help: &str, mut sugg: String) {`
`96`	`96`	`let to_replace = span.source_callsite();`
`97`	`97`
`98`	`98`	`// The callsite span contains the statement semicolon for some reason.`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ declare_clippy_lint! {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`declare_clippy_lint! {`
`59`		`- /// What it does: Checks for public functions that dereferences raw pointer`
	`59`	`+ /// What it does: Checks for public functions that dereference raw pointer`
`60`	`60`	`/// arguments but are not marked unsafe.`
`61`	`61`	`///`
`62`	`62`	/// Why is this bad? The function should probably be marked `unsafe`, since