[WIP] Add PRINTLN_EMPTY_STRING lint.

I have no idea of how I could properly check that there is really an
empty string argument in a `println` invocation.
See `HACK` in print.rs for details.

Author: MaloJaffre

clippy_lints/src/lib.rs

@@ -530,6 +530,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
         partialeq_ne_impl::PARTIALEQ_NE_IMPL,
         precedence::PRECEDENCE,
         print::PRINT_WITH_NEWLINE,
+        print::PRINTLN_EMPTY_STRING,
         ptr::CMP_NULL,
         ptr::MUT_FROM_REF,
         ptr::PTR_ARG,

clippy_lints/src/print.rs

@@ -1,11 +1,30 @@
+use std::ops::Deref;
 use rustc::hir::*;
 use rustc::hir::map::Node::{NodeImplItem, NodeItem};
 use rustc::lint::*;
 use syntax::ast::LitKind;
 use syntax::symbol::InternedString;
+use syntax_pos::Span;
 use utils::{is_expn_of, match_def_path, match_path, resolve_node, span_lint};
 use utils::{paths, opt_def_id};
 
+/// **What it does:** This lint warns when you using `println!("")` to
+/// print a newline.
+///
+/// **Why is this bad?** You should use `println!()`, which is simpler.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// println!("");
+/// ```
+declare_lint! {
+    pub PRINTLN_EMPTY_STRING,
+    Warn,
+    "using `print!()` with a format string that ends in a newline"
+}
+
 /// **What it does:** This lint warns when you using `print!()` with a format
 /// string that
 /// ends in a newline.
@@ -64,7 +83,7 @@ pub struct Pass;
 
 impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
-        lint_array!(PRINT_WITH_NEWLINE, PRINT_STDOUT, USE_DEBUG)
+        lint_array!(PRINT_WITH_NEWLINE, PRINTLN_EMPTY_STRING, PRINT_STDOUT, USE_DEBUG)
     }
 }
 
@@ -88,35 +107,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 
                     span_lint(cx, PRINT_STDOUT, span, &format!("use of `{}!`", name));
 
-                    // Check print! with format string ending in "\n".
-                    if_let_chain!{[
-                        name == "print",
-
-                        // ensure we're calling Arguments::new_v1
-                        args.len() == 1,
-                        let ExprCall(ref args_fun, ref args_args) = args[0].node,
-                        let ExprPath(ref qpath) = args_fun.node,
-                        let Some(const_def_id) = opt_def_id(resolve_node(cx, qpath, args_fun.hir_id)),
-                        match_def_path(cx.tcx, const_def_id, &paths::FMT_ARGUMENTS_NEWV1),
-                        args_args.len() == 2,
-                        let ExprAddrOf(_, ref match_expr) = args_args[1].node,
-                        let ExprMatch(ref args, _, _) = match_expr.node,
-                        let ExprTup(ref args) = args.node,
-
-                        // collect the format string parts and check the last one
-                        let Some((fmtstr, fmtlen)) = get_argument_fmtstr_parts(&args_args[0]),
-                        let Some('\n') = fmtstr.chars().last(),
-
-                        // "foo{}bar" is made into two strings + one argument,
-                        // if the format string starts with `{}` (eg. "{}foo"),
-                        // the string array is prepended an empty string "".
-                        // We only want to check the last string after any `{}`:
-                        args.len() < fmtlen,
-                    ], {
-                        span_lint(cx, PRINT_WITH_NEWLINE, span,
-                                  "using `print!()` with a format string that ends in a \
-                                   newline, consider using `println!()` instead");
-                    }}
+                    match name {
+                        "print" => check_print(cx, span, args),
+                        "println" => check_println(cx, span, args),
+                        _ => (),
+                    }
                 }
             }
             // Search for something like
@@ -135,6 +130,61 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
     }
 }
 
+// Check for print!("... \n", ...).
+fn check_print<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, args: &HirVec<Expr>) {
+    if_let_chain!{[
+        // ensure we're calling Arguments::new_v1
+        args.len() == 1,
+        let ExprCall(ref args_fun, ref args_args) = args[0].node,
+        let ExprPath(ref qpath) = args_fun.node,
+        let Some(const_def_id) = opt_def_id(resolve_node(cx, qpath, args_fun.hir_id)),
+        match_def_path(cx.tcx, const_def_id, &paths::FMT_ARGUMENTS_NEWV1),
+        args_args.len() == 2,
+        let ExprAddrOf(_, ref match_expr) = args_args[1].node,
+        let ExprMatch(ref args, _, _) = match_expr.node,
+        let ExprTup(ref args) = args.node,
+
+        // collect the format string parts and check the last one
+        let Some((fmtstr, fmtlen)) = get_argument_fmtstr_parts(&args_args[0]),
+        let Some('\n') = fmtstr.chars().last(),
+
+        // "foo{}bar" is made into two strings + one argument,
+        // if the format string starts with `{}` (eg. "{}foo"),
+        // the string array is prepended an empty string "".
+        // We only want to check the last string after any `{}`:
+        args.len() < fmtlen,
+    ], {
+        span_lint(cx, PRINT_WITH_NEWLINE, span,
+                  "using `print!()` with a format string that ends in a \
+                   newline, consider using `println!()` instead");
+    }}
+}
+
+/// Check for println!("")
+fn check_println<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, args: &HirVec<Expr>) {
+    if_let_chain!{[
+        // ensure we're calling Arguments::new_v1
+        args.len() == 1,
+        let ExprCall(ref args_fun, ref args_args) = args[0].node,
+        let ExprPath(ref qpath) = args_fun.node,
+        let Some(const_def_id) = opt_def_id(resolve_node(cx, qpath, args_fun.hir_id)),
+        match_def_path(cx.tcx, const_def_id, &paths::FMT_ARGUMENTS_NEWV1),
+        args_args.len() == 2,
+
+        // check that the string is empty
+        let Some((fmtstr, 1)) = get_argument_fmtstr_parts(&args_args[0]),
+        fmtstr.deref() == "\n",
+
+        // HACK: check size of the macro invocation:
+        // println!();  // 11 chars: don't lint
+        // println!("") // 12 chars: lint
+        (span.hi() - span.lo()).0 > 11,
+     ], {
+         span_lint(cx, PRINT_WITH_NEWLINE, span,
+                   "using `println!(\"\")`, consider using `println!()` instead");
+     }}
+}
+
 fn is_in_debug_impl(cx: &LateContext, expr: &Expr) -> bool {
     let map = &cx.tcx.hir;
 

tests/ui/println_empty_string.rs

@@ -0,0 +1,5 @@
+fn main() {
+
+    println!();
+    println!("") // no semicolon intended
+}

tests/ui/println_empty_string.stderr

@@ -0,0 +1,8 @@
+error: using `println!("")`, consider using `println!()` instead
+ --> $DIR/println_empty_string.rs:4:5
+  |
+4 |     println!("") // no semicolon intended
+  |     ^^^^^^^^^^^^
+  |
+  = note: `-D print-with-newline` implied by `-D warnings`
+