fix: auto-fixes for lint concealed_obvious_default

Author: nik-rev

clippy_config/src/conf.rs

@@ -1097,7 +1097,7 @@ impl serde::de::Error for FieldError {
             writeln!(msg).unwrap();
             for (column, column_width) in column_widths.iter().copied().enumerate() {
                 let index = column * rows + row;
-                let field = expected.get(index).copied().unwrap_or_default();
+                let field = expected.get(index).copied().unwrap_or("");
                 write!(msg, "{:SEPARATOR_WIDTH$}{field:column_width$}", " ").unwrap();
             }
         }
@@ -1128,7 +1128,7 @@ fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
                 (0..rows)
                     .map(|row| {
                         let index = column * rows + row;
-                        let field = fields.get(index).copied().unwrap_or_default();
+                        let field = fields.get(index).copied().unwrap_or("");
                         field.len()
                     })
                     .max()

clippy_lints/src/arbitrary_source_item_ordering.rs

@@ -414,7 +414,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
             let module_level_order = self
                 .module_item_order_groupings
                 .module_level_order_of(&item_kind)
-                .unwrap_or_default();
+                .unwrap_or(0);
 
             if let Some(cur_t) = cur_t.as_ref() {
                 use std::cmp::Ordering; // Better legibility.

clippy_lints/src/casts/cast_possible_truncation.rs

@@ -49,7 +49,7 @@ fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: b
                 .min(apply_reductions(cx, nbits, right, signed))
                 .min(apply_reductions(cx, nbits, left, signed)),
             BinOpKind::Shr => apply_reductions(cx, nbits, left, signed)
-                .saturating_sub(constant_int(cx, right).map_or(0, |s| u64::try_from(s).unwrap_or_default())),
+                .saturating_sub(constant_int(cx, right).map_or(0, |s| u64::try_from(s).unwrap_or(0))),
             _ => nbits,
         },
         ExprKind::MethodCall(method, left, [right], _) => {

clippy_lints/src/manual_strip.rs

@@ -269,7 +269,7 @@ fn find_stripping<'tcx>(
 
         fn visit_pat(&mut self, pat: &'tcx rustc_hir::Pat<'tcx>) -> Self::Result {
             if let PatKind::Binding(_, _, ident, _) = pat.kind {
-                *self.bindings.entry(ident.name).or_default() += 1;
+                *self.bindings.entry(ident.name).or_insert(0) += 1;
             }
             walk_pat(self, pat);
         }

clippy_lints/src/operators/arithmetic_side_effects.rs

@@ -64,9 +64,9 @@ impl ArithmeticSideEffects {
     /// "multiplication" are present in the inner set of allowed types.
     fn has_allowed_binary(&self, lhs_ty: Ty<'_>, rhs_ty: Ty<'_>) -> bool {
         let lhs_ty_string = lhs_ty.to_string();
-        let lhs_ty_string_elem = lhs_ty_string.split('<').next().unwrap_or_default();
+        let lhs_ty_string_elem = lhs_ty_string.split('<').next().unwrap_or("");
         let rhs_ty_string = rhs_ty.to_string();
-        let rhs_ty_string_elem = rhs_ty_string.split('<').next().unwrap_or_default();
+        let rhs_ty_string_elem = rhs_ty_string.split('<').next().unwrap_or("");
         if let Some(rhs_from_specific) = self.allowed_binary.get(lhs_ty_string_elem)
             && {
                 let rhs_has_allowed_ty = rhs_from_specific.contains(rhs_ty_string_elem);
@@ -85,7 +85,7 @@ impl ArithmeticSideEffects {
     /// allowed types.
     fn has_allowed_unary(&self, ty: Ty<'_>) -> bool {
         let ty_string = ty.to_string();
-        let ty_string_elem = ty_string.split('<').next().unwrap_or_default();
+        let ty_string_elem = ty_string.split('<').next().unwrap_or("");
         self.allowed_unary.contains(ty_string_elem)
     }
 

clippy_lints/src/utils/author.rs

@@ -216,7 +216,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
 
     fn next(&self, s: &'static str) -> String {
         let mut ids = self.ids.take();
-        let out = match *ids.entry(s).and_modify(|n| *n += 1).or_default() {
+        let out = match *ids.entry(s).and_modify(|n| *n += 1).or_insert(0) {
             // first usage of the name, use it as is
             0 => s.to_string(),
             // append a number starting with 1

clippy_utils/src/lib.rs

@@ -2770,7 +2770,7 @@ pub fn tokenize_with_text(s: &str) -> impl Iterator<Item = (TokenKind, &str, Inn
         let range = pos as usize..end as usize;
         let inner = InnerSpan::new(range.start, range.end);
         pos = end;
-        (t.kind, s.get(range).unwrap_or_default(), inner)
+        (t.kind, s.get(range).unwrap_or(""), inner)
     })
 }
 

clippy_utils/src/ty/mod.rs

@@ -934,7 +934,7 @@ pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
     match (cx.layout_of(ty).map(|layout| layout.size.bytes()), ty.kind()) {
         (Ok(size), _) => size,
         (Err(_), ty::Tuple(list)) => list.iter().map(|t| approx_ty_size(cx, t)).sum(),
-        (Err(_), ty::Array(t, n)) => n.try_to_target_usize(cx.tcx).unwrap_or_default() * approx_ty_size(cx, *t),
+        (Err(_), ty::Array(t, n)) => n.try_to_target_usize(cx.tcx).unwrap_or(0) * approx_ty_size(cx, *t),
         (Err(_), ty::Adt(def, subst)) if def.is_struct() => def
             .variants()
             .iter()
@@ -955,7 +955,7 @@ pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
                     .sum::<u64>()
             })
             .max()
-            .unwrap_or_default(),
+            .unwrap_or(0),
         (Err(_), ty::Adt(def, subst)) if def.is_union() => def
             .variants()
             .iter()
@@ -964,10 +964,10 @@ pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
                     .iter()
                     .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
                     .max()
-                    .unwrap_or_default()
+                    .unwrap_or(0)
             })
             .max()
-            .unwrap_or_default(),
+            .unwrap_or(0),
         (Err(_), _) => 0,
     }
 }

src/driver.rs

@@ -267,7 +267,7 @@ pub fn main() {
         let clippy_args_var = env::var("CLIPPY_ARGS").ok();
         let clippy_args = clippy_args_var
             .as_deref()
-            .unwrap_or_default()
+            .unwrap_or("")
             .split("__CLIPPY_HACKERY__")
             .filter_map(|s| match s {
                 "" => None,