Implement has_string_formatting

Author: smoelius

clippy_lints/src/format.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::higher::{FormatExpn, Formatting};
+use clippy_utils::higher::FormatExpn;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use if_chain::if_chain;
@@ -69,7 +69,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                     _ => false,
                 };
                 if format_args.args().all(|arg| arg.is_display());
-                if !format_args.has_formatting(Formatting::PRECISION | Formatting::WIDTH);
+                if !format_args.has_string_formatting();
                 then {
                     let is_new_string = match value.kind {
                         ExprKind::Binary(..) => true,

clippy_lints/src/format_args.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::higher::{FormatArgsArg, FormatArgsExpn, FormatExpn, Formatting};
+use clippy_utils::higher::{FormatArgsArg, FormatArgsExpn, FormatExpn};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{get_trait_def_id, match_def_path, paths};
@@ -85,7 +85,7 @@ where
         if call_site.from_expansion();
         let expn_data = call_site.ctxt().outer_expn_data();
         if let ExpnKind::Macro(_, name) = expn_data.kind;
-        if !format_args.has_formatting(Formatting::all());
+        if !format_args.has_string_formatting();
         then {
             for (i, arg) in format_args.args().enumerate() {
                 if !arg.is_display() {

clippy_utils/Cargo.toml

@@ -5,7 +5,6 @@ edition = "2021"
 publish = false
 
 [dependencies]
-bitflags = "1.2"
 if_chain = "1.0"
 rustc-semver = "1.1"
 

clippy_utils/src/higher.rs

@@ -4,7 +4,6 @@
 
 use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, last_path_segment, match_def_path, paths};
-use bitflags::bitflags;
 use if_chain::if_chain;
 use rustc_ast::ast::{self, LitKind};
 use rustc_hir as hir;
@@ -574,9 +573,10 @@ impl FormatArgsExpn<'tcx> {
         }
     }
 
-    /// Returns true if any argument has the given formatting types.
-    pub fn has_formatting(&self, formatting: Formatting) -> bool {
-        self.args().any(|arg| arg.has_formatting(formatting))
+    /// Returns true if any argument uses formatting parameters that would have an effect on
+    /// strings.
+    pub fn has_string_formatting(&self) -> bool {
+        self.args().any(|arg| arg.has_string_formatting())
     }
 
     /// Returns an iterator over `FormatArgsArg`.
@@ -660,16 +660,6 @@ pub struct FormatArgsArg<'tcx> {
     fmt: Option<&'tcx Expr<'tcx>>,
 }
 
-bitflags! {
-    pub struct Formatting: u32 {
-        const FILL = 0b0000_0001;
-        const ALIGN = 0b0000_0010;
-        const FLAGS = 0b0000_0100;
-        const PRECISION = 0b0000_1000;
-        const WIDTH = 0b0001_0000;
-    }
-}
-
 impl<'tcx> FormatArgsArg<'tcx> {
     /// An element of `value_args` according to `position`
     pub fn value(&self) -> &'tcx Expr<'tcx> {
@@ -686,12 +676,10 @@ impl<'tcx> FormatArgsArg<'tcx> {
         self.fmt
     }
 
-    /// Returns true if any formatting parameters are used like `{:+2}` instead of just `{}`. Note
-    /// that the check is performed using the logical OR of the flags. So, for example,
-    /// `has_formatting(Formatting:all())` checks whether any (not all) formatting types are
-    /// used.
+    /// Returns true if any formatting parameters are used that would have an effect on strings,
+    /// like `{:+2}` instead of just `{}`.
     #[allow(clippy::nonminimal_bool)]
-    pub fn has_formatting(&self, formatting: Formatting) -> bool {
+    pub fn has_string_formatting(&self) -> bool {
         self.fmt().map_or(false, |fmt| {
             // `!` because these conditions check that `self` is unformatted.
             !if_chain! {
@@ -711,27 +699,11 @@ impl<'tcx> FormatArgsArg<'tcx> {
                 let _ = assert_eq!(precision_field.ident.name, sym::precision);
                 let _ = assert_eq!(width_field.ident.name, sym::width);
 
-                if let ExprKind::Lit(lit) = &fill_field.expr.kind;
-                if let LitKind::Char(char) = lit.node;
-                if !formatting.contains(Formatting::FILL)
-                    || char == ' ';
-
-                if let ExprKind::Path(ref align_path) = align_field.expr.kind;
-                if !formatting.contains(Formatting::ALIGN)
-                    || last_path_segment(align_path).ident.name == sym::Unknown;
-
-                if let ExprKind::Lit(lit) = &flags_field.expr.kind;
-                if let LitKind::Int(u128, _) = lit.node;
-                if !formatting.contains(Formatting::FLAGS)
-                    || u128 == 0;
-
                 if let ExprKind::Path(ref precision_path) = precision_field.expr.kind;
-                if !formatting.contains(Formatting::PRECISION)
-                    || last_path_segment(precision_path).ident.name == sym::Implied;
+                if last_path_segment(precision_path).ident.name == sym::Implied;
 
                 if let ExprKind::Path(ref width_qpath) = width_field.expr.kind;
-                if !formatting.contains(Formatting::WIDTH)
-                    || last_path_segment(width_qpath).ident.name == sym::Implied;
+                if last_path_segment(width_qpath).ident.name == sym::Implied;
 
                 then { true } else { false }
             }