Merge branch 'master' of github.com:rust-lang/rust-clippy

Author: HarrisonMc555

.travis.yml

@@ -50,35 +50,36 @@ matrix:
     # Builds that are only executed when a PR is r+ed or a try build is started
     # We don't want to run these always because they go towards
     # the build limit within the Travis rust-lang account.
+    # The jobs are approximately sorted by execution time
     - env: INTEGRATION=rust-lang/cargo
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-random/rand
+    - env: INTEGRATION=rust-lang-nursery/chalk
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang-nursery/stdsimd
+    - env: INTEGRATION=rust-lang/rls
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang/rustfmt
+    - env: INTEGRATION=Geal/nom
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang-nursery/futures-rs
+    - env: INTEGRATION=rust-lang/rustfmt
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang-nursery/failure
+    - env: INTEGRATION=hyperium/hyper
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang-nursery/log
+    - env: INTEGRATION=bluss/rust-itertools
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang-nursery/chalk
+    - env: INTEGRATION=serde-rs/serde
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=rust-lang/rls
+    - env: INTEGRATION=rust-lang-nursery/stdsimd
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=chronotope/chrono
+    - env: INTEGRATION=rust-random/rand
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=serde-rs/serde
+    - env: INTEGRATION=rust-lang-nursery/futures-rs
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=Geal/nom
+    - env: INTEGRATION=Marwes/combine
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=hyperium/hyper
+    - env: INTEGRATION=rust-lang-nursery/failure
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=bluss/rust-itertools
+    - env: INTEGRATION=rust-lang-nursery/log
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
-    - env: INTEGRATION=Marwes/combine
+    - env: INTEGRATION=chronotope/chrono
       if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
   allow_failures:
   - os: windows

CHANGELOG.md

@@ -896,7 +896,9 @@ All notable changes to this project will be documented in this file.
 [`extra_unused_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes
 [`fallible_impl_from`]: https://rust-lang.github.io/rust-clippy/master/index.html#fallible_impl_from
 [`filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map
+[`filter_map_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next
 [`filter_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_next
+[`find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#find_map
 [`float_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_arithmetic
 [`float_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp
 [`float_cmp_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp_const

Cargo.toml

@@ -48,9 +48,8 @@ rustc_tools_util = { version = "0.1.1", path = "rustc_tools_util"}
 cargo_metadata = "0.7.1"
 compiletest_rs = { version = "0.3.22", features = ["tmp"] }
 lazy_static = "1.0"
-serde_derive = "1.0"
 clippy-mini-macro-test = { version = "0.2", path = "mini-macro" }
-serde = "1.0"
+serde = { version = "1.0", features = ["derive"] }
 derive-new = "0.5"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.

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 299 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are 301 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:
 

appveyor.yml

@@ -8,11 +8,11 @@ environment:
         - TARGET: x86_64-pc-windows-msvc
 
 branches:
-    # Don't build these branches
-    except:
-        # Used by bors
-        - trying.tmp
-        - staging.tmp
+    # Only build AppVeyor on r+, try and the master branch
+    only:
+      - auto
+      - try
+      - master
 
 install:
     - curl -sSf -o rustup-init.exe https://win.rustup.rs/

clippy_lints/Cargo.toml

@@ -24,11 +24,10 @@ matches = "0.1.7"
 quine-mc_cluskey = "0.2.2"
 regex-syntax = "0.6"
 semver = "0.9.0"
-serde = "1.0"
-serde_derive = "1.0"
-toml = "0.4"
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.5"
 unicode-normalization = "0.1"
-pulldown-cmark = "0.2"
+pulldown-cmark = "0.5.0"
 url = "1.7.0"
 if_chain = "0.1.3"
 smallvec = { version = "0.6.5", features = ["union"] }

clippy_lints/src/approx_const.rs

@@ -1,10 +1,13 @@
 use crate::utils::span_lint;
+use crate::utils::sym;
+use lazy_static::lazy_static;
 use rustc::hir::*;
 use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
 use std::f64::consts as f64;
-use syntax::ast::{FloatTy, Lit, LitKind};
+use syntax::ast::{FloatTy, LitKind};
 use syntax::symbol;
+use syntax::symbol::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for floating point literals that approximate
@@ -19,10 +22,7 @@ declare_clippy_lint! {
     /// actually more precise, please [file a Rust
     /// issue](https://github.com/rust-lang/rust/issues).
     ///
-    /// **Known problems:** If you happen to have a value that is within 1/8192 of a
-    /// known constant, but is not *and should not* be the same, this lint will
-    /// report your value anyway. We have not yet noticed any false positives in
-    /// code we tested clippy with (this includes servo), but YMMV.
+    /// **Known problems:** None.
     ///
     /// **Example:**
     /// ```rust
@@ -33,38 +33,40 @@ declare_clippy_lint! {
     "the approximate of a known float constant (in `std::fXX::consts`)"
 }
 
+lazy_static! {
 // Tuples are of the form (constant, name, min_digits)
-const KNOWN_CONSTS: &[(f64, &str, usize)] = &[
-    (f64::E, "E", 4),
-    (f64::FRAC_1_PI, "FRAC_1_PI", 4),
-    (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
-    (f64::FRAC_2_PI, "FRAC_2_PI", 5),
-    (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
-    (f64::FRAC_PI_2, "FRAC_PI_2", 5),
-    (f64::FRAC_PI_3, "FRAC_PI_3", 5),
-    (f64::FRAC_PI_4, "FRAC_PI_4", 5),
-    (f64::FRAC_PI_6, "FRAC_PI_6", 5),
-    (f64::FRAC_PI_8, "FRAC_PI_8", 5),
-    (f64::LN_10, "LN_10", 5),
-    (f64::LN_2, "LN_2", 5),
-    (f64::LOG10_E, "LOG10_E", 5),
-    (f64::LOG2_E, "LOG2_E", 5),
-    (f64::PI, "PI", 3),
-    (f64::SQRT_2, "SQRT_2", 5),
+static ref KNOWN_CONSTS: [(f64, Symbol, usize); 16] = [
+    (f64::E, *sym::E, 4),
+    (f64::FRAC_1_PI, *sym::FRAC_1_PI, 4),
+    (f64::FRAC_1_SQRT_2, *sym::FRAC_1_SQRT_2, 5),
+    (f64::FRAC_2_PI, *sym::FRAC_2_PI, 5),
+    (f64::FRAC_2_SQRT_PI, *sym::FRAC_2_SQRT_PI, 5),
+    (f64::FRAC_PI_2, *sym::FRAC_PI_2, 5),
+    (f64::FRAC_PI_3, *sym::FRAC_PI_3, 5),
+    (f64::FRAC_PI_4, *sym::FRAC_PI_4, 5),
+    (f64::FRAC_PI_6, *sym::FRAC_PI_6, 5),
+    (f64::FRAC_PI_8, *sym::FRAC_PI_8, 5),
+    (f64::LN_10, *sym::LN_10, 5),
+    (f64::LN_2, *sym::LN_2, 5),
+    (f64::LOG10_E, *sym::LOG10_E, 5),
+    (f64::LOG2_E, *sym::LOG2_E, 5),
+    (f64::PI, *sym::PI, 3),
+    (f64::SQRT_2, *sym::SQRT_2, 5),
 ];
+}
 
 declare_lint_pass!(ApproxConstant => [APPROX_CONSTANT]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ApproxConstant {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
         if let ExprKind::Lit(lit) = &e.node {
-            check_lit(cx, lit, e);
+            check_lit(cx, &lit.node, e);
         }
     }
 }
 
-fn check_lit(cx: &LateContext<'_, '_>, lit: &Lit, e: &Expr) {
-    match lit.node {
+fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) {
+    match *lit {
         LitKind::Float(s, FloatTy::F32) => check_known_consts(cx, e, s, "f32"),
         LitKind::Float(s, FloatTy::F64) => check_known_consts(cx, e, s, "f64"),
         LitKind::FloatUnsuffixed(s) => check_known_consts(cx, e, s, "f{32, 64}"),
@@ -75,7 +77,7 @@ fn check_lit(cx: &LateContext<'_, '_>, lit: &Lit, e: &Expr) {
 fn check_known_consts(cx: &LateContext<'_, '_>, e: &Expr, s: symbol::Symbol, module: &str) {
     let s = s.as_str();
     if s.parse::<f64>().is_ok() {
-        for &(constant, name, min_digits) in KNOWN_CONSTS {
+        for &(constant, name, min_digits) in KNOWN_CONSTS.iter() {
             if is_approx_const(constant, &s, min_digits) {
                 span_lint(
                     cx,

clippy_lints/src/assertions_on_constants.rs

@@ -5,7 +5,8 @@ use rustc::{declare_lint_pass, declare_tool_lint};
 use syntax_pos::Span;
 
 use crate::consts::{constant, Constant};
-use crate::utils::{in_macro, is_direct_expn_of, span_help_and_lint};
+use crate::utils::sym;
+use crate::utils::{in_macro_or_desugar, is_direct_expn_of, span_help_and_lint};
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.
@@ -34,16 +35,16 @@ declare_lint_pass!(AssertionsOnConstants => [ASSERTIONS_ON_CONSTANTS]);
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssertionsOnConstants {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
         let mut is_debug_assert = false;
-        let debug_assert_not_in_macro = |span: Span| {
+        let debug_assert_not_in_macro_or_desugar = |span: Span| {
             is_debug_assert = true;
             // Check that `debug_assert!` itself is not inside a macro
-            !in_macro(span)
+            !in_macro_or_desugar(span)
         };
         if_chain! {
-            if let Some(assert_span) = is_direct_expn_of(e.span, "assert");
-            if !in_macro(assert_span)
-                || is_direct_expn_of(assert_span, "debug_assert")
-                    .map_or(false, debug_assert_not_in_macro);
+            if let Some(assert_span) = is_direct_expn_of(e.span, *sym::assert);
+            if !in_macro_or_desugar(assert_span)
+                || is_direct_expn_of(assert_span, *sym::debug_assert)
+                    .map_or(false, debug_assert_not_in_macro_or_desugar);
             if let ExprKind::Unary(_, ref lit) = e.node;
             if let Some(bool_const) = constant(cx, cx.tables, lit);
             then {

clippy_lints/src/assign_ops.rs

@@ -9,6 +9,7 @@ use crate::utils::{
     get_trait_def_id, implements_trait, snippet_opt, span_lint_and_then, trait_ref_of_method, SpanlessEq,
 };
 use crate::utils::{higher, sugg};
+use syntax::symbol::Symbol;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a`
@@ -88,8 +89,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                              $($trait_name:ident),+) => {
                                 match $op {
                                     $(hir::BinOpKind::$trait_name => {
-                                        let [krate, module] = crate::utils::paths::OPS_MODULE;
-                                        let path = [krate, module, concat!(stringify!($trait_name), "Assign")];
+                                        let [krate, module] = *crate::utils::paths::OPS_MODULE;
+                                        let ident = {
+                                            *crate::utils::sym::assign::$trait_name
+                                        };
+                                        let path: [Symbol; 3] = [krate, module, ident];
                                         let trait_id = if let Some(trait_id) = get_trait_def_id($cx, &path) {
                                             trait_id
                                         } else {
@@ -99,7 +103,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                                         let parent_fn = cx.tcx.hir().get_parent_item(e.hir_id);
                                         if_chain! {
                                             if let Some(trait_ref) = trait_ref_of_method(cx, parent_fn);
-                                            if trait_ref.path.def.def_id() == trait_id;
+                                            if trait_ref.path.res.def_id() == trait_id;
                                             then { return; }
                                         }
                                         implements_trait($cx, $ty, trait_id, &[$rty])