X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fformat.rs;h=0cf4762364ba27fe7de31039ef6631fa71a5dc87;hb=778ce4dfd359eb8071ad76aa6447b23ce7a0c752;hp=349ce2cf8b819d0fde29bd7b85dea8c3e194b2be;hpb=c4b37236baa4cee424e74c614fc814e7890aa8b6;p=rust.git

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 349ce2cf8b8..0cf4762364b 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -3,8 +3,9 @@
 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:** Checks for the use of `format!("string literal with no
 /// argument")` and `format!("{}", foo)` where `foo` is a string.
@@ -13,7 +14,7 @@
 /// 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`.
+/// if `foo: &str`.
 ///
 /// **Known problems:** None.
 ///
@@ -37,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
@@ -72,23 +73,23 @@ fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
 /// 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<&'a str>> {
+                                         -> 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 exprs) = expr.node,
+        let ExprAddrOf(_, ref expr) = expr.node, // &["…", "…", …]
+        let ExprArray(ref exprs) = expr.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);
+                    result.push(lit.as_str());
                 }
             }
         }
@@ -99,7 +100,7 @@ pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Exp
 
 /// Checks if the expressions matches
 /// ```rust
-/// { static __STATIC_FMTSTR: &[""] = _; __STATIC_FMTSTR }
+/// { static __STATIC_FMTSTR: … = &["…", "…", …]; __STATIC_FMTSTR }
 /// ```
 fn check_static_str(cx: &LateContext, expr: &Expr) -> bool {
     if let Some(expr) = get_argument_fmtstr_parts(cx, expr) {
@@ -123,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);
     }}