Merge branch 'master' of github.com:Manishearth/rust-clippy into fold_any

Author: oli-obk

.travis.yml

@@ -4,7 +4,7 @@ rust: nightly
 
 os:
   - linux
-  - osx
+  # - osx # doesn't even start atm. Not sure what travis is up to. Disabling to reduce the noise
 
 sudo: false
 

CHANGELOG.md

@@ -1,6 +1,9 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## 0.0.180
+* Rustup to *rustc 1.25.0-nightly (3f92e8d89 2018-01-14)*
+
 ## 0.0.179
 * Rustup to *rustc 1.25.0-nightly (61452e506 2018-01-09)*
 
@@ -580,6 +583,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
+[`inline_fn_without_body`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#inline_fn_without_body
 [`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_ref`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#invalid_ref
@@ -670,6 +674,7 @@ All notable changes to this project will be documented in this file.
 [`redundant_closure_call`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#redundant_closure_call
 [`redundant_pattern`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#redundant_pattern
 [`regex_macro`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#regex_macro
+[`replace_consts`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#replace_consts
 [`result_map_unwrap_or_else`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#result_map_unwrap_or_else
 [`result_unwrap_used`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`reverse_range_loop`]: https://rust-lang-nursery.github.io/rust-clippy/master/index.html#reverse_range_loop

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.0.179"
+version = "0.0.180"
 authors = [
 	"Manish Goregaokar <[email protected]>",
 	"Andre Bogus <[email protected]>",
@@ -37,13 +37,13 @@ path = "src/driver.rs"
 
 [dependencies]
 # begin automatic update
-clippy_lints = { version = "0.0.179", path = "clippy_lints" }
+clippy_lints = { version = "0.0.180", path = "clippy_lints" }
 # end automatic update
 cargo_metadata = "0.2"
 regex = "0.2"
 
 [dev-dependencies]
-compiletest_rs = "0.3"
+compiletest_rs = "0.3.5"
 duct = "0.8.2"
 lazy_static = "1.0"
 serde_derive = "1.0"

clippy_lints/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "clippy_lints"
 # begin automatic update
-version = "0.0.179"
+version = "0.0.180"
 # end automatic update
 authors = [
 	"Manish Goregaokar <[email protected]>",

clippy_lints/src/const_static_lifetime.rs

@@ -1,6 +1,6 @@
 use syntax::ast::{Item, ItemKind, Ty, TyKind};
 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
-use utils::{in_macro, span_lint_and_then};
+use utils::{in_macro, snippet, span_lint_and_then};
 
 /// **What it does:** Checks for constants with an explicit `'static` lifetime.
 ///
@@ -51,14 +51,15 @@ impl StaticConst {
                         TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) |
                         TyKind::Tup(..) => {
                             if lifetime.ident.name == "'static" {
-                                let mut sug: String = String::new();
+                                let snip = snippet(cx, borrow_type.ty.span, "<type>");
+                                let sugg = format!("&{}", snip);
                                 span_lint_and_then(
                                     cx,
                                     CONST_STATIC_LIFETIME,
                                     lifetime.span,
                                     "Constants have by default a `'static` lifetime",
                                     |db| {
-                                        db.span_suggestion(lifetime.span, "consider removing `'static`", sug);
+                                        db.span_suggestion(ty.span, "consider removing `'static`", sugg);
                                     },
                                 );
                             }

clippy_lints/src/else_if_without_else.rs

@@ -0,0 +1,70 @@
+//! lint on if expressions with an else if, but without a final else branch
+
+use rustc::lint::*;
+use syntax::ast::*;
+
+use utils::{in_external_macro, span_lint_and_sugg};
+
+/// **What it does:** Checks for usage of if expressions with an `else if` branch,
+/// but without a final `else` branch.
+///
+/// **Why is this bad?** Some coding guidelines require this (e.g. MISRA-C:2004 Rule 14.10).
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// if x.is_positive() {
+///     a();
+/// } else if x.is_negative() {
+///     b();
+/// }
+/// ```
+///
+/// Could be written:
+///
+/// ```rust
+/// if x.is_positive() {
+///     a();
+/// } else if x.is_negative() {
+///     b();
+/// } else {
+///     // we don't care about zero
+/// }
+/// ```
+declare_restriction_lint! {
+    pub ELSE_IF_WITHOUT_ELSE,
+    "if expression with an `else if`, but without a final `else` branch"
+}
+
+#[derive(Copy, Clone)]
+pub struct ElseIfWithoutElse;
+
+impl LintPass for ElseIfWithoutElse {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(ELSE_IF_WITHOUT_ELSE)
+    }
+}
+
+impl EarlyLintPass for ElseIfWithoutElse {
+    fn check_expr(&mut self, cx: &EarlyContext, mut item: &Expr) {
+        if in_external_macro(cx, item.span) {
+            return;
+        }
+
+        while let ExprKind::If(_, _, Some(ref els)) = item.node {
+            if let ExprKind::If(_, _, None) = els.node {
+                span_lint_and_sugg(
+                    cx,
+                    ELSE_IF_WITHOUT_ELSE,
+                    els.span,
+                    "if expression with an `else if`, but without a final `else`",
+                    "add an `else` block here",
+                    "".to_string()
+                );
+            }
+
+            item = els;
+        }
+    }
+}

clippy_lints/src/functions.rs

@@ -86,7 +86,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
         use rustc::hir::map::Node::*;
 
         let is_impl = if let Some(NodeItem(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent_node(nodeid)) {
-            matches!(item.node, hir::ItemImpl(_, _, _, _, Some(_), _, _) | hir::ItemAutoImpl(..))
+            matches!(item.node, hir::ItemImpl(_, _, _, _, Some(_), _, _))
         } else {
             false
         };

clippy_lints/src/inline_fn_without_body.rs

@@ -0,0 +1,65 @@
+//! checks for `#[inline]` on trait methods without bodies
+
+use rustc::lint::*;
+use rustc::hir::*;
+use syntax::ast::{Attribute, Name};
+use utils::span_lint_and_then;
+use utils::sugg::DiagnosticBuilderExt;
+
+/// **What it does:** Checks for `#[inline]` on trait methods without bodies
+///
+/// **Why is this bad?** Only implementations of trait methods may be inlined.
+/// The inline attribute is ignored for trait methods without bodies.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// trait Animal {
+///     #[inline]
+///     fn name(&self) -> &'static str;
+/// }
+/// ```
+declare_lint! {
+    pub INLINE_FN_WITHOUT_BODY,
+    Warn,
+    "use of `#[inline]` on trait methods without bodies"
+}
+
+#[derive(Copy, Clone)]
+pub struct Pass;
+
+impl LintPass for Pass {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(INLINE_FN_WITHOUT_BODY)
+    }
+}
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
+    fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
+        match item.node {
+            TraitItemKind::Method(_, TraitMethod::Required(_)) => {
+                check_attrs(cx, &item.name, &item.attrs);
+            },
+            _ => {},
+        }
+    }
+}
+
+fn check_attrs(cx: &LateContext, name: &Name, attrs: &[Attribute]) {
+    for attr in attrs {
+        if attr.name().map_or(true, |n| n != "inline") {
+            continue;
+        }
+
+        span_lint_and_then(
+            cx,
+            INLINE_FN_WITHOUT_BODY,
+            attr.span,
+            &format!("use of `#[inline]` on trait method `{}` which has no body", name),
+            |db| {
+                db.suggest_remove_item(cx, attr.span, "remove");
+            },
+        );
+    }
+}