update to the rust-PR that unblocks clippy

[rust.git] / clippy_lints / src / format.rs

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 2b3835d780fa10f8a77b9927cbfabbdc86db512f..0cf4762364ba27fe7de31039ef6631fa71a5dc87 100644 (file)
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -3,19 +3,26 @@
 use rustc::lint::*;
 use rustc::ty::TypeVariants;
 use syntax::ast::LitKind;
+use syntax::symbol::InternedString;
 use utils::paths;
-use utils::{is_expn_of, match_path, match_type, span_lint, walk_ptrs_ty};
+use utils::{is_expn_of, match_def_path, match_type, resolve_node, span_lint, walk_ptrs_ty};
 
-/// **What it does:** This lints about use of `format!("string literal with no argument")` and
-/// `format!("{}", foo)` where `foo` is a string.
+/// **What it does:** Checks for the use of `format!("string literal with no
+/// argument")` and `format!("{}", foo)` where `foo` is a string.
 ///
-/// **Why is this bad?** There is no point of doing that. `format!("too")` can be replaced by `"foo".to_owned()` if you really need a `String`. The even worse `&format!("foo")` is often
-/// encountered in the wild. `format!("{}", foo)` can be replaced by `foo.clone()` if `foo: String`
-/// or `foo.to_owned()` is `foo: &str`.
+/// **Why is this bad?** There is no point of doing that. `format!("too")` can
+/// be replaced by `"foo".to_owned()` if you really need a `String`. The even
+/// worse `&format!("foo")` is often encountered in the wild. `format!("{}",
+/// foo)` can be replaced by `foo.clone()` if `foo: String` or `foo.to_owned()`
+/// if `foo: &str`.
 ///
 /// **Known problems:** None.
 ///
-/// **Examples:** `format!("foo")` and `format!("{}", foo)`
+/// **Examples:**
+/// ```rust
+/// format!("foo")
+/// format!("{}", foo)
+/// ```
 declare_lint! {
     pub USELESS_FORMAT,
     Warn,
@@ -31,16 +38,16 @@ fn get_lints(&self) -> LintArray {
     }
 }
 
-impl LateLintPass for Pass {
-    fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
         if let Some(span) = is_expn_of(cx, expr.span, "format") {
             match expr.node {
                 // `format!("{}", foo)` expansion
                 ExprCall(ref fun, ref args) => {
                     if_let_chain!{[
-                        let ExprPath(_, ref path) = fun.node,
+                        let ExprPath(ref qpath) = fun.node,
                         args.len() == 2,
-                        match_path(path, &paths::FMT_ARGUMENTS_NEWV1),
+                        match_def_path(cx, resolve_node(cx, qpath, fun.id).def_id(), &paths::FMT_ARGUMENTS_NEWV1),
                         // ensure the format string is `"{..}"` with only one argument and no text
                         check_static_str(cx, &args[0]),
                         // ensure the format argument is `{}` ie. Display with no fancy option
@@ -63,34 +70,48 @@ fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
     }
 }
 
-/// Checks if the expressions matches
-/// ```
-/// { static __STATIC_FMTSTR: &[""] = _; __STATIC_FMTSTR }
-/// ```
-fn check_static_str(cx: &LateContext, expr: &Expr) -> bool {
+/// 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>> {
     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.map.find(decl.id),
-        decl.name.as_str() == "__STATIC_FMTSTR",
+        &*decl.name.as_str() == "__STATIC_FMTSTR",
         let ItemStatic(_, _, ref expr) = decl.node,
-        let ExprAddrOf(_, ref expr) = expr.node, // &[""]
-        let ExprVec(ref expr) = expr.node,
-        expr.len() == 1,
-        let ExprLit(ref lit) = expr[0].node,
-        let LitKind::Str(ref lit, _) = lit.node,
-        lit.is_empty()
+        let ExprAddrOf(_, ref expr) = expr.node, // &["…", "…", …]
+        let ExprArray(ref exprs) = expr.node,
     ], {
-        return true;
+        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);
     }}
-
-    false
+    None
 }
 
 /// Checks if the expressions matches
+/// ```rust
+/// { static __STATIC_FMTSTR: … = &["…", "…", …]; __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
+    }
+}
+
+/// Checks if the expressions matches
+/// ```rust
 /// &match (&42,) {
 ///     (__arg0,) => [::std::fmt::ArgumentV1::new(__arg0, ::std::fmt::Display::fmt)],
 /// })
@@ -103,14 +124,14 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool {
         arms[0].pats.len() == 1,
         let PatKind::Tuple(ref pat, None) = arms[0].pats[0].node,
         pat.len() == 1,
-        let ExprVec(ref exprs) = arms[0].body.node,
+        let ExprArray(ref exprs) = arms[0].body.node,
         exprs.len() == 1,
         let ExprCall(_, ref args) = exprs[0].node,
         args.len() == 2,
-        let ExprPath(None, ref path) = args[1].node,
-        match_path(path, &paths::DISPLAY_FMT_METHOD)
+        let ExprPath(ref qpath) = args[1].node,
+        match_def_path(cx, resolve_node(cx, qpath, args[1].id).def_id(), &paths::DISPLAY_FMT_METHOD),
     ], {
-        let ty = walk_ptrs_ty(cx.tcx.pat_ty(&pat[0]));
+        let ty = walk_ptrs_ty(cx.tcx.tables().pat_ty(&pat[0]));
 
         return ty.sty == TypeVariants::TyStr || match_type(cx, ty, &paths::STRING);
     }}