2018-09-06 10:33:00 +00:00
|
|
|
use crate::utils::{snippet, span_lint, span_lint_and_sugg};
|
2018-09-15 07:21:58 +00:00
|
|
|
use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
|
|
|
|
use crate::rustc::{declare_tool_lint, lint_array};
|
2018-09-06 10:33:00 +00:00
|
|
|
use std::borrow::Cow;
|
2018-09-15 07:21:58 +00:00
|
|
|
use crate::syntax::ast::*;
|
|
|
|
use crate::syntax::parse::{parser, token};
|
|
|
|
use crate::syntax::tokenstream::{ThinTokenStream, TokenStream};
|
2018-04-05 03:46:39 +00:00
|
|
|
|
|
|
|
/// **What it does:** This lint warns when you use `println!("")` to
|
|
|
|
/// print a newline.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** You should use `println!()`, which is simpler.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// println!("");
|
|
|
|
/// ```
|
|
|
|
declare_clippy_lint! {
|
|
|
|
pub PRINTLN_EMPTY_STRING,
|
|
|
|
style,
|
|
|
|
"using `println!(\"\")` with an empty string"
|
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** This lint warns when you use `print!()` with a format
|
|
|
|
/// string that
|
|
|
|
/// ends in a newline.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** You should use `println!()` instead, which appends the
|
|
|
|
/// newline.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// print!("Hello {}!\n", name);
|
|
|
|
/// ```
|
2018-08-11 22:16:03 +00:00
|
|
|
/// use println!() instead
|
|
|
|
/// ```rust
|
|
|
|
/// println!("Hello {}!", name);
|
|
|
|
/// ```
|
2018-04-05 03:46:39 +00:00
|
|
|
declare_clippy_lint! {
|
|
|
|
pub PRINT_WITH_NEWLINE,
|
|
|
|
style,
|
2018-08-07 20:01:10 +00:00
|
|
|
"using `print!()` with a format string that ends in a single newline"
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** Checks for printing on *stdout*. The purpose of this lint
|
|
|
|
/// is to catch debugging remnants.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** People often print on *stdout* while debugging an
|
|
|
|
/// application and might forget to remove those prints afterward.
|
|
|
|
///
|
|
|
|
/// **Known problems:** Only catches `print!` and `println!` calls.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// println!("Hello world!");
|
|
|
|
/// ```
|
|
|
|
declare_clippy_lint! {
|
|
|
|
pub PRINT_STDOUT,
|
|
|
|
restriction,
|
|
|
|
"printing on stdout"
|
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** Checks for use of `Debug` formatting. The purpose of this
|
|
|
|
/// lint is to catch debugging remnants.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** The purpose of the `Debug` trait is to facilitate
|
|
|
|
/// debugging Rust code. It should not be used in in user-facing output.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// println!("{:?}", foo);
|
|
|
|
/// ```
|
|
|
|
declare_clippy_lint! {
|
|
|
|
pub USE_DEBUG,
|
|
|
|
restriction,
|
|
|
|
"use of `Debug`-based formatting"
|
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** This lint warns about the use of literals as `print!`/`println!` args.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** Using literals as `println!` args is inefficient
|
|
|
|
/// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
|
|
|
|
/// (i.e., just put the literal in the format string)
|
|
|
|
///
|
|
|
|
/// **Known problems:** Will also warn with macro calls as arguments that expand to literals
|
|
|
|
/// -- e.g., `println!("{}", env!("FOO"))`.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// println!("{}", "foo");
|
|
|
|
/// ```
|
2018-08-11 22:16:03 +00:00
|
|
|
/// use the literal without formatting:
|
|
|
|
/// ```rust
|
|
|
|
/// println!("foo");
|
|
|
|
/// ```
|
2018-04-05 03:46:39 +00:00
|
|
|
declare_clippy_lint! {
|
|
|
|
pub PRINT_LITERAL,
|
|
|
|
style,
|
|
|
|
"printing a literal with a format string"
|
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** This lint warns when you use `writeln!(buf, "")` to
|
|
|
|
/// print a newline.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** You should use `writeln!(buf)`, which is simpler.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// writeln!("");
|
|
|
|
/// ```
|
|
|
|
declare_clippy_lint! {
|
|
|
|
pub WRITELN_EMPTY_STRING,
|
|
|
|
style,
|
|
|
|
"using `writeln!(\"\")` with an empty string"
|
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** This lint warns when you use `write!()` with a format
|
|
|
|
/// string that
|
|
|
|
/// ends in a newline.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** You should use `writeln!()` instead, which appends the
|
|
|
|
/// newline.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// write!(buf, "Hello {}!\n", name);
|
|
|
|
/// ```
|
|
|
|
declare_clippy_lint! {
|
|
|
|
pub WRITE_WITH_NEWLINE,
|
|
|
|
style,
|
2018-08-07 20:01:10 +00:00
|
|
|
"using `write!()` with a format string that ends in a single newline"
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// **What it does:** This lint warns about the use of literals as `write!`/`writeln!` args.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** Using literals as `writeln!` args is inefficient
|
|
|
|
/// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
|
|
|
|
/// (i.e., just put the literal in the format string)
|
|
|
|
///
|
|
|
|
/// **Known problems:** Will also warn with macro calls as arguments that expand to literals
|
|
|
|
/// -- e.g., `writeln!(buf, "{}", env!("FOO"))`.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// writeln!(buf, "{}", "foo");
|
|
|
|
/// ```
|
|
|
|
declare_clippy_lint! {
|
|
|
|
pub WRITE_LITERAL,
|
|
|
|
style,
|
|
|
|
"writing a literal with a format string"
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
|
|
pub struct Pass;
|
|
|
|
|
|
|
|
impl LintPass for Pass {
|
|
|
|
fn get_lints(&self) -> LintArray {
|
|
|
|
lint_array!(
|
|
|
|
PRINT_WITH_NEWLINE,
|
|
|
|
PRINTLN_EMPTY_STRING,
|
|
|
|
PRINT_STDOUT,
|
|
|
|
USE_DEBUG,
|
|
|
|
PRINT_LITERAL,
|
|
|
|
WRITE_WITH_NEWLINE,
|
|
|
|
WRITELN_EMPTY_STRING,
|
|
|
|
WRITE_LITERAL
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-22 22:19:07 +00:00
|
|
|
impl EarlyLintPass for Pass {
|
2018-07-23 11:01:12 +00:00
|
|
|
fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &Mac) {
|
2018-07-22 22:19:07 +00:00
|
|
|
if mac.node.path == "println" {
|
|
|
|
span_lint(cx, PRINT_STDOUT, mac.span, "use of `println!`");
|
2018-08-16 16:20:06 +00:00
|
|
|
if let Some(fmtstr) = check_tts(cx, &mac.node.tts, false).0 {
|
2018-07-22 22:19:07 +00:00
|
|
|
if fmtstr == "" {
|
|
|
|
span_lint_and_sugg(
|
|
|
|
cx,
|
|
|
|
PRINTLN_EMPTY_STRING,
|
|
|
|
mac.span,
|
|
|
|
"using `println!(\"\")`",
|
|
|
|
"replace it with",
|
|
|
|
"println!()".to_string(),
|
|
|
|
);
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-22 22:19:07 +00:00
|
|
|
} else if mac.node.path == "print" {
|
|
|
|
span_lint(cx, PRINT_STDOUT, mac.span, "use of `print!`");
|
2018-08-16 16:20:06 +00:00
|
|
|
if let Some(fmtstr) = check_tts(cx, &mac.node.tts, false).0 {
|
2018-09-06 10:55:04 +00:00
|
|
|
if fmtstr.ends_with("\\n") &&
|
|
|
|
// don't warn about strings with several `\n`s (#3126)
|
|
|
|
fmtstr.matches("\\n").count() == 1
|
|
|
|
{
|
2018-09-06 10:33:00 +00:00
|
|
|
span_lint(
|
|
|
|
cx,
|
|
|
|
PRINT_WITH_NEWLINE,
|
|
|
|
mac.span,
|
|
|
|
"using `print!()` with a format string that ends in a \
|
|
|
|
single newline, consider using `println!()` instead",
|
|
|
|
);
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-22 22:19:07 +00:00
|
|
|
} else if mac.node.path == "write" {
|
2018-08-16 16:20:06 +00:00
|
|
|
if let Some(fmtstr) = check_tts(cx, &mac.node.tts, true).0 {
|
2018-09-06 10:55:04 +00:00
|
|
|
if fmtstr.ends_with("\\n") &&
|
|
|
|
// don't warn about strings with several `\n`s (#3126)
|
|
|
|
fmtstr.matches("\\n").count() == 1
|
|
|
|
{
|
2018-09-06 10:33:00 +00:00
|
|
|
span_lint(
|
|
|
|
cx,
|
|
|
|
WRITE_WITH_NEWLINE,
|
|
|
|
mac.span,
|
|
|
|
"using `write!()` with a format string that ends in a \
|
|
|
|
single newline, consider using `writeln!()` instead",
|
|
|
|
);
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-22 22:19:07 +00:00
|
|
|
} else if mac.node.path == "writeln" {
|
2018-08-16 16:20:06 +00:00
|
|
|
let check_tts = check_tts(cx, &mac.node.tts, true);
|
|
|
|
if let Some(fmtstr) = check_tts.0 {
|
2018-07-22 22:19:07 +00:00
|
|
|
if fmtstr == "" {
|
2018-09-06 10:33:00 +00:00
|
|
|
let suggestion = check_tts
|
|
|
|
.1
|
|
|
|
.map_or(Cow::Borrowed("v"), |expr| snippet(cx, expr.span, "v"));
|
2018-08-20 12:03:13 +00:00
|
|
|
|
2018-07-22 22:19:07 +00:00
|
|
|
span_lint_and_sugg(
|
|
|
|
cx,
|
|
|
|
WRITELN_EMPTY_STRING,
|
|
|
|
mac.span,
|
2018-08-20 13:50:15 +00:00
|
|
|
format!("using `writeln!({}, \"\")`", suggestion).as_str(),
|
2018-07-22 22:19:07 +00:00
|
|
|
"replace it with",
|
2018-08-20 13:33:43 +00:00
|
|
|
format!("writeln!({})", suggestion),
|
2018-07-22 22:19:07 +00:00
|
|
|
);
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-16 16:20:06 +00:00
|
|
|
fn check_tts<'a>(cx: &EarlyContext<'a>, tts: &ThinTokenStream, is_write: bool) -> (Option<String>, Option<Expr>) {
|
2018-10-08 00:05:28 +00:00
|
|
|
use crate::fmt_macros::*;
|
2018-07-22 22:19:07 +00:00
|
|
|
let tts = TokenStream::from(tts.clone());
|
2018-09-06 10:33:00 +00:00
|
|
|
let mut parser = parser::Parser::new(&cx.sess.parse_sess, tts, None, false, false);
|
2018-08-20 12:03:13 +00:00
|
|
|
let mut expr: Option<Expr> = None;
|
|
|
|
if is_write {
|
2018-08-20 13:33:43 +00:00
|
|
|
expr = match parser.parse_expr().map_err(|mut err| err.cancel()) {
|
|
|
|
Ok(p) => Some(p.into_inner()),
|
|
|
|
Err(_) => return (None, None),
|
2018-08-20 12:03:13 +00:00
|
|
|
};
|
|
|
|
// might be `writeln!(foo)`
|
2018-08-20 13:33:43 +00:00
|
|
|
if parser.expect(&token::Comma).map_err(|mut err| err.cancel()).is_err() {
|
2018-08-20 12:03:13 +00:00
|
|
|
return (None, expr);
|
|
|
|
}
|
|
|
|
}
|
2018-08-16 16:20:06 +00:00
|
|
|
|
2018-08-20 13:33:43 +00:00
|
|
|
let fmtstr = match parser.parse_str().map_err(|mut err| err.cancel()) {
|
|
|
|
Ok(token) => token.0.to_string(),
|
|
|
|
Err(_) => return (None, expr),
|
2018-08-20 12:03:13 +00:00
|
|
|
};
|
2018-07-22 22:19:07 +00:00
|
|
|
let tmp = fmtstr.clone();
|
|
|
|
let mut args = vec![];
|
|
|
|
let mut fmt_parser = Parser::new(&tmp, None);
|
|
|
|
while let Some(piece) = fmt_parser.next() {
|
|
|
|
if !fmt_parser.errors.is_empty() {
|
2018-08-16 16:20:06 +00:00
|
|
|
return (None, expr);
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
2018-07-22 22:19:07 +00:00
|
|
|
if let Piece::NextArgument(arg) = piece {
|
|
|
|
if arg.format.ty == "?" {
|
|
|
|
// FIXME: modify rustc's fmt string parser to give us the current span
|
|
|
|
span_lint(cx, USE_DEBUG, parser.prev_span, "use of `Debug`-based formatting");
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
2018-07-22 22:19:07 +00:00
|
|
|
args.push(arg);
|
2018-04-05 03:46:39 +00:00
|
|
|
}
|
|
|
|
}
|
2018-09-06 10:33:00 +00:00
|
|
|
let lint = if is_write { WRITE_LITERAL } else { PRINT_LITERAL };
|
2018-07-22 22:19:07 +00:00
|
|
|
let mut idx = 0;
|
|
|
|
loop {
|
|
|
|
if !parser.eat(&token::Comma) {
|
2018-08-16 16:20:06 +00:00
|
|
|
return (Some(fmtstr), expr);
|
2018-07-22 22:19:07 +00:00
|
|
|
}
|
2018-08-20 13:33:43 +00:00
|
|
|
let token_expr = match parser.parse_expr().map_err(|mut err| err.cancel()) {
|
|
|
|
Ok(expr) => expr,
|
|
|
|
Err(_) => return (Some(fmtstr), None),
|
2018-08-20 12:03:13 +00:00
|
|
|
};
|
2018-07-23 11:01:12 +00:00
|
|
|
const SIMPLE: FormatSpec<'_> = FormatSpec {
|
2018-07-22 22:19:07 +00:00
|
|
|
fill: None,
|
|
|
|
align: AlignUnknown,
|
|
|
|
flags: 0,
|
|
|
|
precision: CountImplied,
|
|
|
|
width: CountImplied,
|
|
|
|
ty: "",
|
|
|
|
};
|
2018-08-20 12:03:13 +00:00
|
|
|
match &token_expr.node {
|
2018-07-22 22:19:07 +00:00
|
|
|
ExprKind::Lit(_) => {
|
|
|
|
let mut all_simple = true;
|
|
|
|
let mut seen = false;
|
|
|
|
for arg in &args {
|
|
|
|
match arg.position {
|
2018-09-06 10:33:00 +00:00
|
|
|
ArgumentImplicitlyIs(n) | ArgumentIs(n) => if n == idx {
|
2018-07-22 22:19:07 +00:00
|
|
|
all_simple &= arg.format == SIMPLE;
|
|
|
|
seen = true;
|
|
|
|
},
|
|
|
|
ArgumentNamed(_) => {},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if all_simple && seen {
|
2018-08-20 12:03:13 +00:00
|
|
|
span_lint(cx, lint, token_expr.span, "literal with an empty format string");
|
2018-07-22 22:19:07 +00:00
|
|
|
}
|
|
|
|
idx += 1;
|
|
|
|
},
|
|
|
|
ExprKind::Assign(lhs, rhs) => {
|
2018-07-25 21:31:17 +00:00
|
|
|
if let ExprKind::Lit(_) = rhs.node {
|
|
|
|
if let ExprKind::Path(_, p) = &lhs.node {
|
|
|
|
let mut all_simple = true;
|
|
|
|
let mut seen = false;
|
|
|
|
for arg in &args {
|
|
|
|
match arg.position {
|
2018-09-06 10:33:00 +00:00
|
|
|
ArgumentImplicitlyIs(_) | ArgumentIs(_) => {},
|
2018-07-25 21:31:17 +00:00
|
|
|
ArgumentNamed(name) => if *p == name {
|
|
|
|
seen = true;
|
|
|
|
all_simple &= arg.format == SIMPLE;
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if all_simple && seen {
|
|
|
|
span_lint(cx, lint, rhs.span, "literal with an empty format string");
|
2018-07-22 22:19:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => idx += 1,
|
2018-04-21 18:24:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|