X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fformat.rs;h=0cf4762364ba27fe7de31039ef6631fa71a5dc87;hb=778ce4dfd359eb8071ad76aa6447b23ce7a0c752;hp=0726fcaeab71eeb6bd317fb1a7b3f6986f9ccb41;hpb=9110b6eb601ff45dcf31e9ed58fa4d93a3b24220;p=rust.git diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index 0726fcaeab7..0cf4762364b 100644 --- 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, @@ -23,24 +30,24 @@ } #[derive(Copy, Clone, Debug)] -pub struct FormatMacLint; +pub struct Pass; -impl LintPass for FormatMacLint { +impl LintPass for Pass { fn get_lints(&self) -> LintArray { lint_array![USELESS_FORMAT] } } -impl LateLintPass for FormatMacLint { - 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> { 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)], /// }) @@ -101,16 +122,16 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool { let ExprMatch(_, ref arms, _) = expr.node, arms.len() == 1, arms[0].pats.len() == 1, - let PatKind::Tup(ref pat) = arms[0].pats[0].node, + 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); }}