Merge branch 'master' into no_effect_with_drop

Author: jugglerchris

.travis.yml

@@ -28,6 +28,7 @@ script:
  - cargo test --features debugging
  - mkdir -p ~/rust/cargo/bin
  - cp target/debug/cargo-clippy ~/rust/cargo/bin/cargo-clippy
+ - cp target/debug/clippy-driver ~/rust/cargo/bin/clippy-driver
  - PATH=$PATH:~/rust/cargo/bin cargo clippy --all -- -D clippy
  - cd clippy_workspace_tests && PATH=$PATH:~/rust/cargo/bin cargo clippy -- -D clippy && cd ..
  - cd clippy_workspace_tests/src && PATH=$PATH:~/rust/cargo/bin cargo clippy -- -D clippy && cd ../..

CHANGELOG.md

@@ -1,6 +1,22 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## 0.0.165
+* Rust upgrade to rustc 1.22.0-nightly (0e6f4cf51 2017-09-27)
+* New lint: [`mut_range_bound`]
+
+## 0.0.164
+* Update to *rustc 1.22.0-nightly (6c476ce46 2017-09-25)*
+* New lint: [`int_plus_one`]
+
+## 0.0.163
+* Update to *rustc 1.22.0-nightly (14039a42a 2017-09-22)*
+
+## 0.0.162
+* Update to *rustc 1.22.0-nightly (0701b37d9 2017-09-18)*
+* New lint: [`chars_last_cmp`]
+* Improved suggestions for [`needless_borrow`], [`ptr_arg`],
+
 ## 0.0.161
 * Update to *rustc 1.22.0-nightly (539f2083d 2017-09-13)*
 
@@ -457,6 +473,7 @@ All notable changes to this project will be documented in this file.
 [`cast_precision_loss`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#cast_precision_loss
 [`cast_sign_loss`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#cast_sign_loss
 [`char_lit_as_u8`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#char_lit_as_u8
+[`chars_last_cmp`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#chars_last_cmp
 [`chars_next_cmp`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#chars_next_cmp
 [`clone_double_ref`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#clone_double_ref
 [`clone_on_copy`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#clone_on_copy
@@ -510,6 +527,7 @@ All notable changes to this project will be documented in this file.
 [`ineffective_bit_mask`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#ineffective_bit_mask
 [`infinite_iter`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#infinite_iter
 [`inline_always`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#inline_always
+[`int_plus_one`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#int_plus_one
 [`integer_arithmetic`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#integer_arithmetic
 [`invalid_regex`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#invalid_regex
 [`invalid_upcast_comparisons`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
@@ -547,6 +565,7 @@ All notable changes to this project will be documented in this file.
 [`modulo_one`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#modulo_one
 [`mut_from_ref`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#mut_from_ref
 [`mut_mut`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#mut_mut
+[`mut_range_bound`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#mut_range_bound
 [`mutex_atomic`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#mutex_atomic
 [`mutex_integer`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#mutex_integer
 [`naive_bytecount`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#naive_bytecount

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.0.161"
+version = "0.0.165"
 authors = [
 	"Manish Goregaokar <[email protected]>",
 	"Andre Bogus <[email protected]>",
@@ -14,6 +14,7 @@ readme = "README.md"
 license = "MPL-2.0"
 keywords = ["clippy", "lint", "plugin"]
 categories = ["development-tools", "development-tools::cargo-plugins"]
+build = "build.rs"
 
 [badges]
 travis-ci = { repository = "rust-lang-nursery/rust-clippy" }
@@ -29,9 +30,14 @@ name = "cargo-clippy"
 test = false
 path = "src/main.rs"
 
+[[bin]]
+name = "clippy-driver"
+test = false
+path = "src/driver.rs"
+
 [dependencies]
 # begin automatic update
-clippy_lints = { version = "0.0.161", path = "clippy_lints" }
+clippy_lints = { version = "0.0.165", path = "clippy_lints" }
 # end automatic update
 cargo_metadata = "0.2"
 

Cargo.toml

@@ -7,7 +7,7 @@ Steps to publish a new clippy version
 - `git push`
 - Wait for Travis's approval.
 - Merge.
-- `cargo publish` in `./clippy_clints`.
+- `cargo publish` in `./clippy_lints`.
 - `cargo publish` in the root directory.
 - `git pull`.
 - `git tag -s v0.0.X -m "v0.0.X"`.

PUBLISH.md

@@ -0,0 +1,8 @@
+use std::env;
+
+fn main() {
+    // Forward the profile to the main compilation
+    println!("cargo:rustc-env=PROFILE={}", env::var("PROFILE").unwrap());
+    // Don't rebuild even if nothing changed
+    println!("cargo:rerun-if-changed=build.rs");
+}

build.rs

@@ -1,7 +1,7 @@
 [package]
 name = "clippy_lints"
 # begin automatic update
-version = "0.0.161"
+version = "0.0.165"
 # end automatic update
 authors = [
 	"Manish Goregaokar <[email protected]>",
@@ -28,6 +28,7 @@ serde_derive = "1.0"
 toml = "0.4"
 unicode-normalization = "0.1"
 pulldown-cmark = "0.0.15"
+url = "1.5.0"
 
 [features]
 debugging = []

clippy_lints/Cargo.toml

@@ -90,7 +90,17 @@ declare_lint! {
 }
 
 #[derive(Copy, Clone)]
-pub struct BitMask;
+pub struct BitMask {
+    verbose_bit_mask_threshold: u64,
+}
+
+impl BitMask {
+    pub fn new(verbose_bit_mask_threshold: u64) -> Self {
+        Self {
+            verbose_bit_mask_threshold: verbose_bit_mask_threshold,
+        }
+    }
+}
 
 impl LintPass for BitMask {
     fn get_lints(&self) -> LintArray {
@@ -119,6 +129,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask {
             let Expr_::ExprLit(ref lit1) = right.node,
             let LitKind::Int(0, _) = lit1.node,
             n.leading_zeros() == n.count_zeros(),
+            n > u128::from(self.verbose_bit_mask_threshold),
         ], {
             span_lint_and_then(cx,
                                VERBOSE_BIT_MASK,
@@ -307,7 +318,7 @@ fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option<u128> {
                         cx.tcx.mir_const_qualif(def_id);
                         cx.tcx.hir.body(cx.tcx.hir.body_owned_by(id))
                     } else {
-                        cx.tcx.extern_const_body(def_id)
+                        cx.tcx.extern_const_body(def_id).body
                     };
                     fetch_int_literal(cx, &body.value)
                 })

clippy_lints/src/bit_mask.rs

@@ -298,7 +298,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> {
                         self.tcx.mir_const_qualif(def_id);
                         self.tcx.hir.body(self.tcx.hir.body_owned_by(id))
                     } else {
-                        self.tcx.extern_const_body(def_id)
+                        self.tcx.extern_const_body(def_id).body
                     };
                     let ret = cx.expr(&body.value);
                     if ret.is_some() {

clippy_lints/src/consts.rs

@@ -5,6 +5,7 @@ use syntax::ast;
 use syntax::codemap::{BytePos, Span};
 use syntax_pos::Pos;
 use utils::span_lint;
+use url::Url;
 
 /// **What it does:** Checks for the presence of `_`, `::` or camel-case words
 /// outside ticks in documentation.
@@ -195,16 +196,26 @@ fn check_doc<'a, Events: Iterator<Item = (usize, pulldown_cmark::Event<'a>)>>(
     use pulldown_cmark::Tag::*;
 
     let mut in_code = false;
+    let mut in_link = None;
 
     for (offset, event) in docs {
         match event {
             Start(CodeBlock(_)) | Start(Code) => in_code = true,
             End(CodeBlock(_)) | End(Code) => in_code = false,
-            Start(_tag) | End(_tag) => (),         // We don't care about other tags
+            Start(Link(link, _)) => in_link = Some(link),
+            End(Link(_, _)) => in_link = None,
+            Start(_tag) | End(_tag) => (), // We don't care about other tags
             Html(_html) | InlineHtml(_html) => (), // HTML is weird, just ignore it
             SoftBreak => (),
             HardBreak => (),
             FootnoteReference(text) | Text(text) => {
+                if Some(&text) == in_link.as_ref() {
+                    // Probably a link of the form `<http://example.com>`
+                    // Which are represented as a link to "http://example.com" with
+                    // text "http://example.com" by pulldown-cmark
+                    continue;
+                }
+
                 if !in_code {
                     let index = match spans.binary_search_by(|c| c.0.cmp(&offset)) {
                         Ok(o) => o,
@@ -270,6 +281,18 @@ fn check_word(cx: &EarlyContext, word: &str, span: Span) {
         s != "_" && !s.contains("\\_") && s.contains('_')
     }
 
+    if let Ok(url) = Url::parse(word) {
+        // try to get around the fact that `foo::bar` parses as a valid URL
+        if !url.cannot_be_a_base() {
+            span_lint(cx,
+                      DOC_MARKDOWN,
+                      span,
+                      "you should put bare URLs between `<`/`>` or make a proper Markdown link");
+
+            return;
+        }
+    }
+
     if has_underscore(word) || word.contains("::") || is_camel_case(word) {
         span_lint(
             cx,

clippy_lints/src/doc.rs

@@ -1,9 +1,7 @@
 use rustc::hir::*;
-use rustc::hir::map::Node::NodeItem;
 use rustc::lint::*;
 use rustc::ty;
 use syntax::ast::LitKind;
-use syntax::symbol::InternedString;
 use utils::paths;
 use utils::{is_expn_of, match_def_path, match_type, resolve_node, span_lint, walk_ptrs_ty, opt_def_id};
 
@@ -50,8 +48,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
                         let Some(fun_def_id) = opt_def_id(resolve_node(cx, qpath, fun.hir_id)),
                         match_def_path(cx.tcx, fun_def_id, &paths::FMT_ARGUMENTS_NEWV1),
                         // ensure the format string is `"{..}"` with only one argument and no text
-                        check_static_str(cx, &args[0]),
+                        check_static_str(&args[0]),
                         // ensure the format argument is `{}` ie. Display with no fancy option
+                        // and that the argument is a string
                         check_arg_is_display(cx, &args[1])
                     ], {
                         span_lint(cx, USELESS_FORMAT, span, "useless use of `format!`");
@@ -69,44 +68,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 }
 
-/// Returns the slice of format string parts in an `Arguments::new_v1` call.
-/// Public because it's shared with a lint in print.rs.
-pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Expr) -> Option<Vec<InternedString>> {
+/// Checks if the expressions matches `&[""]`
+fn check_static_str(expr: &Expr) -> bool {
     if_let_chain! {[
-        let ExprBlock(ref block) = expr.node,
-        block.stmts.len() == 1,
-        let StmtDecl(ref decl, _) = block.stmts[0].node,
-        let DeclItem(ref decl) = decl.node,
-        let Some(NodeItem(decl)) = cx.tcx.hir.find(decl.id),
-        decl.name == "__STATIC_FMTSTR",
-        let ItemStatic(_, _, ref expr) = decl.node,
-        let ExprAddrOf(_, ref expr) = cx.tcx.hir.body(*expr).value.node, // &["…", "…", …]
-        let ExprArray(ref exprs) = expr.node,
+        let ExprAddrOf(_, ref expr) = expr.node, // &[""]
+        let ExprArray(ref exprs) = expr.node, // [""]
+        exprs.len() == 1,
+        let ExprLit(ref lit) = exprs[0].node,
+        let LitKind::Str(ref lit, _) = lit.node,
     ], {
-        let mut result = Vec::new();
-        for expr in exprs {
-            if let ExprLit(ref lit) = expr.node {
-                if let LitKind::Str(ref lit, _) = lit.node {
-                    result.push(lit.as_str());
-                }
-            }
-        }
-        return Some(result);
+        return lit.as_str().is_empty();
     }}
-    None
-}
 
-/// Checks if the expressions matches
-/// ```rust, ignore
-/// { static __STATIC_FMTSTR: &'static[&'static str] = &["a", "b", c];
-/// __STATIC_FMTSTR }
-/// ```
-fn check_static_str(cx: &LateContext, expr: &Expr) -> bool {
-    if let Some(expr) = get_argument_fmtstr_parts(cx, expr) {
-        expr.len() == 1 && expr[0].is_empty()
-    } else {
-        false
-    }
+    false
 }
 
 /// Checks if the expressions matches

clippy_lints/src/format.rs

@@ -0,0 +1,96 @@
+use rustc::lint::*;
+use rustc::hir::*;
+use syntax::ast::NodeId;
+use utils::{in_macro, match_def_path, match_trait_method, same_tys, snippet, span_lint_and_then};
+use utils::{opt_def_id, paths, resolve_node};
+
+/// **What it does:** Checks for always-identical `Into`/`From` conversions.
+///
+/// **Why is this bad?** Redundant code.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// // format!() returns a `String`
+/// let s: String = format!("hello").into();
+/// ```
+declare_lint! {
+    pub IDENTITY_CONVERSION,
+    Warn,
+    "using always-identical `Into`/`From` conversions"
+}
+
+#[derive(Default)]
+pub struct IdentityConversion {
+    try_desugar_arm: Vec<NodeId>,
+}
+
+impl LintPass for IdentityConversion {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(IDENTITY_CONVERSION)
+    }
+}
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+        if in_macro(e.span) {
+            return;
+        }
+
+        if Some(&e.id) == self.try_desugar_arm.last() {
+            return;
+        }
+
+        match e.node {
+            ExprMatch(_, ref arms, MatchSource::TryDesugar) => {
+                let e = match arms[0].body.node {
+                    ExprRet(Some(ref e)) | ExprBreak(_, Some(ref e)) => e,
+                    _ => return,
+                };
+                if let ExprCall(_, ref args) = e.node {
+                    self.try_desugar_arm.push(args[0].id);
+                } else {
+                    return;
+                }
+            },
+
+            ExprMethodCall(ref name, .., ref args) => {
+                if match_trait_method(cx, e, &paths::INTO[..]) && &*name.name.as_str() == "into" {
+                    let a = cx.tables.expr_ty(e);
+                    let b = cx.tables.expr_ty(&args[0]);
+                    if same_tys(cx, a, b) {
+                        let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
+                        span_lint_and_then(cx, IDENTITY_CONVERSION, e.span, "identical conversion", |db| {
+                            db.span_suggestion(e.span, "consider removing `.into()`", sugg);
+                        });
+                    }
+                }
+            },
+
+            ExprCall(ref path, ref args) => if let ExprPath(ref qpath) = path.node {
+                if let Some(def_id) = opt_def_id(resolve_node(cx, qpath, path.hir_id)) {
+                    if match_def_path(cx.tcx, def_id, &paths::FROM_FROM[..]) {
+                        let a = cx.tables.expr_ty(e);
+                        let b = cx.tables.expr_ty(&args[0]);
+                        if same_tys(cx, a, b) {
+                            let sugg = snippet(cx, args[0].span, "<expr>").into_owned();
+                            let sugg_msg = format!("consider removing `{}()`", snippet(cx, path.span, "From::from"));
+                            span_lint_and_then(cx, IDENTITY_CONVERSION, e.span, "identical conversion", |db| {
+                                db.span_suggestion(e.span, &sugg_msg, sugg);
+                            });
+                        }
+                    }
+                }
+            },
+
+            _ => {},
+        }
+    }
+
+    fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
+        if Some(&e.id) == self.try_desugar_arm.last() {
+            self.try_desugar_arm.pop();
+        }
+    }
+}