4 use crate::utils::{snippet_with_applicability, span_lint, span_lint_and_sugg, span_lint_and_then};
5 use rustc_ast::ast::{Expr, ExprKind, Item, ItemKind, MacCall, StrLit, StrStyle};
7 use rustc_ast::tokenstream::TokenStream;
8 use rustc_errors::Applicability;
9 use rustc_lexer::unescape::{self, EscapeError};
10 use rustc_lint::{EarlyContext, EarlyLintPass};
11 use rustc_parse::parser;
12 use rustc_session::{declare_tool_lint, impl_lint_pass};
13 use rustc_span::symbol::Symbol;
14 use rustc_span::{BytePos, Span};
16 declare_clippy_lint! {
17 /// **What it does:** This lint warns when you use `println!("")` to
20 /// **Why is this bad?** You should use `println!()`, which is simpler.
22 /// **Known problems:** None.
32 pub PRINTLN_EMPTY_STRING,
34 "using `println!(\"\")` with an empty string"
37 declare_clippy_lint! {
38 /// **What it does:** This lint warns when you use `print!()` with a format
39 /// string that ends in a newline.
41 /// **Why is this bad?** You should use `println!()` instead, which appends the
44 /// **Known problems:** None.
48 /// # let name = "World";
49 /// print!("Hello {}!\n", name);
51 /// use println!() instead
53 /// # let name = "World";
54 /// println!("Hello {}!", name);
56 pub PRINT_WITH_NEWLINE,
58 "using `print!()` with a format string that ends in a single newline"
61 declare_clippy_lint! {
62 /// **What it does:** Checks for printing on *stdout*. The purpose of this lint
63 /// is to catch debugging remnants.
65 /// **Why is this bad?** People often print on *stdout* while debugging an
66 /// application and might forget to remove those prints afterward.
68 /// **Known problems:** Only catches `print!` and `println!` calls.
72 /// println!("Hello world!");
79 declare_clippy_lint! {
80 /// **What it does:** Checks for use of `Debug` formatting. The purpose of this
81 /// lint is to catch debugging remnants.
83 /// **Why is this bad?** The purpose of the `Debug` trait is to facilitate
84 /// debugging Rust code. It should not be used in user-facing output.
88 /// # let foo = "bar";
89 /// println!("{:?}", foo);
93 "use of `Debug`-based formatting"
96 declare_clippy_lint! {
97 /// **What it does:** This lint warns about the use of literals as `print!`/`println!` args.
99 /// **Why is this bad?** Using literals as `println!` args is inefficient
100 /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
101 /// (i.e., just put the literal in the format string)
103 /// **Known problems:** Will also warn with macro calls as arguments that expand to literals
104 /// -- e.g., `println!("{}", env!("FOO"))`.
108 /// println!("{}", "foo");
110 /// use the literal without formatting:
116 "printing a literal with a format string"
119 declare_clippy_lint! {
120 /// **What it does:** This lint warns when you use `writeln!(buf, "")` to
123 /// **Why is this bad?** You should use `writeln!(buf)`, which is simpler.
125 /// **Known problems:** None.
129 /// # use std::fmt::Write;
130 /// # let mut buf = String::new();
133 /// writeln!(buf, "");
138 pub WRITELN_EMPTY_STRING,
140 "using `writeln!(buf, \"\")` with an empty string"
143 declare_clippy_lint! {
144 /// **What it does:** This lint warns when you use `write!()` with a format
146 /// ends in a newline.
148 /// **Why is this bad?** You should use `writeln!()` instead, which appends the
151 /// **Known problems:** None.
155 /// # use std::fmt::Write;
156 /// # let mut buf = String::new();
157 /// # let name = "World";
160 /// write!(buf, "Hello {}!\n", name);
163 /// writeln!(buf, "Hello {}!", name);
165 pub WRITE_WITH_NEWLINE,
167 "using `write!()` with a format string that ends in a single newline"
170 declare_clippy_lint! {
171 /// **What it does:** This lint warns about the use of literals as `write!`/`writeln!` args.
173 /// **Why is this bad?** Using literals as `writeln!` args is inefficient
174 /// (c.f., https://github.com/matthiaskrgr/rust-str-bench) and unnecessary
175 /// (i.e., just put the literal in the format string)
177 /// **Known problems:** Will also warn with macro calls as arguments that expand to literals
178 /// -- e.g., `writeln!(buf, "{}", env!("FOO"))`.
182 /// # use std::fmt::Write;
183 /// # let mut buf = String::new();
186 /// writeln!(buf, "{}", "foo");
189 /// writeln!(buf, "foo");
193 "writing a literal with a format string"
201 impl_lint_pass!(Write => [
203 PRINTLN_EMPTY_STRING,
208 WRITELN_EMPTY_STRING,
212 impl EarlyLintPass for Write {
213 fn check_item(&mut self, _: &EarlyContext<'_>, item: &Item) {
214 if let ItemKind::Impl {
215 of_trait: Some(trait_ref),
219 let trait_name = trait_ref
224 .expect("path has at least one segment")
227 if trait_name == sym!(Debug) {
228 self.in_debug_impl = true;
233 fn check_item_post(&mut self, _: &EarlyContext<'_>, _: &Item) {
234 self.in_debug_impl = false;
237 fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &MacCall) {
238 if mac.path == sym!(println) {
239 span_lint(cx, PRINT_STDOUT, mac.span(), "use of `println!`");
240 if let (Some(fmt_str), _) = self.check_tts(cx, &mac.args.inner_tokens(), false) {
241 if fmt_str.symbol == Symbol::intern("") {
244 PRINTLN_EMPTY_STRING,
246 "using `println!(\"\")`",
248 "println!()".to_string(),
249 Applicability::MachineApplicable,
253 } else if mac.path == sym!(print) {
254 span_lint(cx, PRINT_STDOUT, mac.span(), "use of `print!`");
255 if let (Some(fmt_str), _) = self.check_tts(cx, &mac.args.inner_tokens(), false) {
256 if check_newlines(&fmt_str) {
261 "using `print!()` with a format string that ends in a single newline",
263 err.multipart_suggestion(
264 "use `println!` instead",
266 (mac.path.span, String::from("println")),
267 (newline_span(&fmt_str), String::new()),
269 Applicability::MachineApplicable,
275 } else if mac.path == sym!(write) {
276 if let (Some(fmt_str), _) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
277 if check_newlines(&fmt_str) {
282 "using `write!()` with a format string that ends in a single newline",
284 err.multipart_suggestion(
285 "use `writeln!()` instead",
287 (mac.path.span, String::from("writeln")),
288 (newline_span(&fmt_str), String::new()),
290 Applicability::MachineApplicable,
296 } else if mac.path == sym!(writeln) {
297 if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) {
298 if fmt_str.symbol == Symbol::intern("") {
299 let mut applicability = Applicability::MachineApplicable;
300 let suggestion = expr.map_or_else(
302 applicability = Applicability::HasPlaceholders;
305 |e| snippet_with_applicability(cx, e.span, "v", &mut Applicability::MachineApplicable),
310 WRITELN_EMPTY_STRING,
312 format!("using `writeln!({}, \"\")`", suggestion).as_str(),
314 format!("writeln!({})", suggestion),
323 /// Given a format string that ends in a newline and its span, calculates the span of the
325 fn newline_span(fmtstr: &StrLit) -> Span {
326 let sp = fmtstr.span;
327 let contents = &fmtstr.symbol.as_str();
329 let newline_sp_hi = sp.hi()
330 - match fmtstr.style {
331 StrStyle::Cooked => BytePos(1),
332 StrStyle::Raw(hashes) => BytePos((1 + hashes).into()),
335 let newline_sp_len = if contents.ends_with('\n') {
337 } else if contents.ends_with(r"\n") {
340 panic!("expected format string to contain a newline");
343 sp.with_lo(newline_sp_hi - newline_sp_len).with_hi(newline_sp_hi)
347 /// Checks the arguments of `print[ln]!` and `write[ln]!` calls. It will return a tuple of two
348 /// `Option`s. The first `Option` of the tuple is the macro's format string. It includes
349 /// the contents of the string, whether it's a raw string, and the span of the literal in the
350 /// source. The second `Option` in the tuple is, in the `write[ln]!` case, the expression the
351 /// `format_str` should be written to.
355 /// Calling this function on
357 /// # use std::fmt::Write;
358 /// # let mut buf = String::new();
359 /// # let something = "something";
360 /// writeln!(buf, "string to write: {}", something);
364 /// (Some("string to write: {}"), Some(buf))
366 #[allow(clippy::too_many_lines)]
369 cx: &EarlyContext<'a>,
372 ) -> (Option<StrLit>, Option<Expr>) {
373 use rustc_parse_format::{
374 AlignUnknown, ArgumentImplicitlyIs, ArgumentIs, ArgumentNamed, CountImplied, FormatSpec, ParseMode, Parser,
377 let tts = tts.clone();
379 let mut parser = parser::Parser::new(&cx.sess.parse_sess, tts, false, None);
380 let mut expr: Option<Expr> = None;
382 expr = match parser.parse_expr().map_err(|mut err| err.cancel()) {
383 Ok(p) => Some(p.into_inner()),
384 Err(_) => return (None, None),
386 // might be `writeln!(foo)`
387 if parser.expect(&token::Comma).map_err(|mut err| err.cancel()).is_err() {
392 let fmtstr = match parser.parse_str_lit() {
393 Ok(fmtstr) => fmtstr,
394 Err(_) => return (None, expr),
396 let tmp = fmtstr.symbol.as_str();
397 let mut args = vec![];
398 let mut fmt_parser = Parser::new(&tmp, None, None, false, ParseMode::Format);
399 while let Some(piece) = fmt_parser.next() {
400 if !fmt_parser.errors.is_empty() {
403 if let Piece::NextArgument(arg) = piece {
404 if !self.in_debug_impl && arg.format.ty == "?" {
405 // FIXME: modify rustc's fmt string parser to give us the current span
406 span_lint(cx, USE_DEBUG, parser.prev_token.span, "use of `Debug`-based formatting");
411 let lint = if is_write { WRITE_LITERAL } else { PRINT_LITERAL };
414 const SIMPLE: FormatSpec<'_> = FormatSpec {
418 precision: CountImplied,
419 precision_span: None,
425 if !parser.eat(&token::Comma) {
426 return (Some(fmtstr), expr);
428 let token_expr = if let Ok(expr) = parser.parse_expr().map_err(|mut err| err.cancel()) {
431 return (Some(fmtstr), None);
433 match &token_expr.kind {
434 ExprKind::Lit(_) => {
435 let mut all_simple = true;
436 let mut seen = false;
439 ArgumentImplicitlyIs(n) | ArgumentIs(n) => {
441 all_simple &= arg.format == SIMPLE;
445 ArgumentNamed(_) => {},
448 if all_simple && seen {
449 span_lint(cx, lint, token_expr.span, "literal with an empty format string");
453 ExprKind::Assign(lhs, rhs, _) => {
454 if let ExprKind::Lit(_) = rhs.kind {
455 if let ExprKind::Path(_, p) = &lhs.kind {
456 let mut all_simple = true;
457 let mut seen = false;
460 ArgumentImplicitlyIs(_) | ArgumentIs(_) => {},
461 ArgumentNamed(name) => {
464 all_simple &= arg.format == SIMPLE;
469 if all_simple && seen {
470 span_lint(cx, lint, rhs.span, "literal with an empty format string");
481 /// Checks if the format string contains a single newline that terminates it.
483 /// Literal and escaped newlines are both checked (only literal for raw strings).
484 fn check_newlines(fmtstr: &StrLit) -> bool {
485 let mut has_internal_newline = false;
486 let mut last_was_cr = false;
487 let mut should_lint = false;
489 let contents = &fmtstr.symbol.as_str();
491 let mut cb = |r: Range<usize>, c: Result<char, EscapeError>| {
494 if r.end == contents.len() && c == '\n' && !last_was_cr && !has_internal_newline {
497 last_was_cr = c == '\r';
499 has_internal_newline = true;
505 StrStyle::Cooked => unescape::unescape_literal(contents, unescape::Mode::Str, &mut cb),
506 StrStyle::Raw(_) => unescape::unescape_literal(contents, unescape::Mode::RawStr, &mut cb),