Fix string_lit_as_bytes lint for macros

Prior to this change, string_lit_as_bytes would trigger for constructs
like `include_str!("filename").as_bytes()` and would recommend fixing it
by rewriting as `binclude_str!("filename")`.

This change updates the lint to act as an EarlyLintPass lint. It then
differentiates between string literals and macros that have bytes
yielding alternatives.

Closes #3205

Author: yaahc

clippy_lints/src/lib.rs

@@ -174,6 +174,7 @@ pub mod returns;
 pub mod serde_api;
 pub mod shadow;
 pub mod strings;
+pub mod strings_early;
 pub mod suspicious_trait_impl;
 pub mod swap;
 pub mod temporary_assignment;
@@ -200,6 +201,7 @@ mod reexport {
 pub fn register_pre_expansion_lints(session: &rustc::session::Session, store: &mut rustc::lint::LintStore, conf: &Conf) {
     store.register_pre_expansion_pass(Some(session), box write::Pass);
     store.register_pre_expansion_pass(Some(session), box redundant_field_names::RedundantFieldNames);
+    store.register_pre_expansion_pass(Some(session), box strings_early::StringLitAsBytes);
     store.register_pre_expansion_pass(Some(session), box non_expressive_names::NonExpressiveNames {
         single_char_binding_names_threshold: conf.single_char_binding_names_threshold,
     });
@@ -355,7 +357,6 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry<'_>, conf: &Conf) {
     reg.register_late_lint_pass(box escape::Pass{too_large_for_stack: conf.too_large_for_stack});
     reg.register_early_lint_pass(box misc_early::MiscEarly);
     reg.register_late_lint_pass(box panic_unimplemented::Pass);
-    reg.register_late_lint_pass(box strings::StringLitAsBytes);
     reg.register_late_lint_pass(box derive::Derive);
     reg.register_late_lint_pass(box types::CharLitAsU8);
     reg.register_late_lint_pass(box vec::Pass);

clippy_lints/src/strings.rs

@@ -3,7 +3,7 @@ use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
 use crate::rustc::{declare_tool_lint, lint_array};
 use crate::syntax::source_map::Spanned;
 use crate::utils::SpanlessEq;
-use crate::utils::{get_parent_expr, is_allowed, match_type, paths, span_lint, span_lint_and_sugg, walk_ptrs_ty};
+use crate::utils::{get_parent_expr, is_allowed, match_type, paths, span_lint, walk_ptrs_ty};
 
 /// **What it does:** Checks for string appends of the form `x = x + y` (without
 /// `let`!).
@@ -133,38 +133,3 @@ fn is_add(cx: &LateContext<'_, '_>, src: &Expr, target: &Expr) -> bool {
         _ => false,
     }
 }
-
-#[derive(Copy, Clone)]
-pub struct StringLitAsBytes;
-
-impl LintPass for StringLitAsBytes {
-    fn get_lints(&self) -> LintArray {
-        lint_array!(STRING_LIT_AS_BYTES)
-    }
-}
-
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringLitAsBytes {
-    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
-        use crate::syntax::ast::LitKind;
-        use crate::utils::{in_macro, snippet};
-
-        if let ExprKind::MethodCall(ref path, _, ref args) = e.node {
-            if path.ident.name == "as_bytes" {
-                if let ExprKind::Lit(ref lit) = args[0].node {
-                    if let LitKind::Str(ref lit_content, _) = lit.node {
-                        if lit_content.as_str().chars().all(|c| c.is_ascii()) && !in_macro(args[0].span) {
-                            span_lint_and_sugg(
-                                cx,
-                                STRING_LIT_AS_BYTES,
-                                e.span,
-                                "calling `as_bytes()` on a string literal",
-                                "consider using a byte string literal instead",
-                                format!("b{}", snippet(cx, args[0].span, r#""foo""#)),
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

clippy_lints/src/strings_early.rs

@@ -0,0 +1,68 @@
+use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
+use crate::rustc::{declare_tool_lint, lint_array};
+use crate::utils::span_lint_and_sugg;
+
+/// **What it does:** Checks for the `as_bytes` method called on string literals
+/// that contain only ASCII characters.
+///
+/// **Why is this bad?** Byte string literals (e.g. `b"foo"`) can be used
+/// instead. They are shorter but less discoverable than `as_bytes()`.
+///
+/// **Known Problems:** None.
+///
+/// **Example:**
+/// ```rust
+/// let bs = "a byte string".as_bytes();
+/// ```
+declare_clippy_lint! {
+    pub STRING_LIT_AS_BYTES,
+    style,
+    "calling `as_bytes` on a string literal instead of using a byte string literal"
+}
+
+#[derive(Copy, Clone)]
+pub struct StringLitAsBytes;
+
+impl LintPass for StringLitAsBytes {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(STRING_LIT_AS_BYTES)
+    }
+}
+
+impl EarlyLintPass for StringLitAsBytes {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &crate::syntax::ast::Expr) {
+        use crate::syntax::ast::{ExprKind, LitKind};
+        use crate::utils::{in_macro, snippet};
+
+        if let ExprKind::MethodCall(ref path, ref args) = e.node {
+            if path.ident.name == "as_bytes" {
+                if let ExprKind::Lit(ref lit) = args[0].node {
+                    if let LitKind::Str(ref lit_content, _) = lit.node {
+                        if lit_content.as_str().chars().all(|c| c.is_ascii()) && !in_macro(args[0].span) {
+                            span_lint_and_sugg(
+                                cx,
+                                STRING_LIT_AS_BYTES,
+                                e.span,
+                                "calling `as_bytes()` on a string literal",
+                                "consider using a byte string literal instead",
+                                format!("b{}", snippet(cx, args[0].span, r#""foo""#)),
+                            );
+                        }
+                    }
+                } else if let ExprKind::Mac(ref mac) = args[0].node {
+                    if mac.node.path == "include_str" {
+                        cx.sess.err(&format!("{:?}", mac));
+                        span_lint_and_sugg(
+                            cx,
+                            STRING_LIT_AS_BYTES,
+                            e.span,
+                            "calling `as_bytes()` on a include_str macro",
+                            "consider using include_bytes instead",
+                            format!("include_str{}", snippet(cx, mac.span, "include_bytes")),
+                        );
+                    }
+                }
+            }
+        }
+    }
+}

tests/ui/strings.rs

@@ -44,17 +44,6 @@ fn both() {
     assert_eq!(&x, &z);
 }
 
-#[allow(dead_code, unused_variables)]
-#[warn(clippy::string_lit_as_bytes)]
-fn str_lit_as_bytes() {
-    let bs = "hello there".as_bytes();
-
-    // no warning, because this cannot be written as a byte string literal:
-    let ubs = "☃".as_bytes();
-
-    let strify = stringify!(foobar).as_bytes();
-}
-
 fn main() {
     add_only();
     add_assign_only();

tests/ui/strings.stderr

@@ -52,20 +52,6 @@ error: you added something to a string. Consider using `String::push_str()` inst
 42 |     let z = y + "...";
    |             ^^^^^^^^^
 
-error: calling `as_bytes()` on a string literal
-  --> $DIR/strings.rs:50:14
-   |
-50 |     let bs = "hello there".as_bytes();
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"hello there"`
-   |
-   = note: `-D clippy::string-lit-as-bytes` implied by `-D warnings`
-
-error: calling `as_bytes()` on a string literal
-  --> $DIR/strings.rs:55:18
-   |
-55 |     let strify = stringify!(foobar).as_bytes();
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `bstringify!(foobar)`
-
 error: manual implementation of an assign operation
   --> $DIR/strings.rs:65:7
    |

tests/ui/strings_early.rs

@@ -0,0 +1,18 @@
+#![feature(tool_lints)]
+
+#[allow(dead_code, unused_variables)]
+#[warn(clippy::string_lit_as_bytes)]
+fn str_lit_as_bytes() {
+    let bs = "hello there".as_bytes();
+
+    // no warning, because this cannot be written as a byte string literal:
+    let ubs = "☃".as_bytes();
+
+    let strify = stringify!(foobar).as_bytes();
+
+    let includestr = include_str!("entry.rs").as_bytes();
+}
+
+fn main() {
+    assert_eq!(2, 2);
+}

tests/ui/strings_early.stderr

@@ -0,0 +1,16 @@
+error: calling `as_bytes()` on a string literal
+ --> $DIR/strings_early.rs:6:14
+  |
+6 |     let bs = "hello there".as_bytes();
+  |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"hello there"`
+  |
+  = note: `-D clippy::string-lit-as-bytes` implied by `-D warnings`
+
+error: calling `as_bytes()` on a string literal
+  --> $DIR/strings_early.rs:11:18
+   |
+11 |     let strify = stringify!(foobar).as_bytes();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `bstringify!(foobar)`
+
+error: aborting due to 2 previous errors
+