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 2013b406f2b78524177f8bbe3e510ea6b050caa9..0cf4762364ba27fe7de31039ef6631fa71a5dc87 100644 (file)
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -3,6 +3,7 @@
 use rustc::lint::*;
 use rustc::ty::TypeVariants;
 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};
 
@@ -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,17 +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(..) = fun.node,
+                        let ExprPath(ref qpath) = fun.node,
                         args.len() == 2,
-                        let Some(fun) = resolve_node(cx, fun.id),
-                        match_def_path(cx, fun.def_id(), &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
@@ -73,14 +73,14 @@ 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 ExprArray(ref exprs) = expr.node,
@@ -89,7 +89,7 @@ pub fn get_argument_fmtstr_parts<'a, 'b>(cx: &LateContext<'a, 'b>, expr: &'a Exp
         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());
                 }
             }
         }
@@ -128,9 +128,8 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool {
         exprs.len() == 1,
         let ExprCall(_, ref args) = exprs[0].node,
         args.len() == 2,
-        let ExprPath(None, _) = args[1].node,
-        let Some(fun) = resolve_node(cx, args[1].id),
-        match_def_path(cx, fun.def_id(), &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.tables().pat_ty(&pat[0]));