fix(or_fun_call): respect MSRV for unwrap_or_default suggestion

clippy_lints/src/methods/mod.rs

@@ -4412,7 +4412,7 @@ declare_clippy_lint! {
     /// Checks for calls to `Read::bytes` on types which don't implement `BufRead`.
     ///
     /// ### Why is this bad?
-    /// The default implementation calls `read` for each byte, which can be very inefficient for data that’s not in memory, such as `File`.
+    /// The default implementation calls `read` for each byte, which can be very inefficient for data that's not in memory, such as `File`.
     ///
     /// ### Example
     /// ```no_run
@@ -4741,7 +4741,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             },
             ExprKind::MethodCall(method_call, receiver, args, _) => {
                 let method_span = method_call.ident.span;
-                or_fun_call::check(cx, expr, method_span, method_call.ident.name, receiver, args);
+                or_fun_call::check(cx, expr, method_span, method_call.ident.name, receiver, args, self.msrv);
                 expect_fun_call::check(
                     cx,
                     &self.format_args,

clippy_lints/src/methods/or_fun_call.rs

@@ -1,7 +1,9 @@
+#![allow(clippy::too_many_arguments)]
 use std::ops::ControlFlow;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{expr_type_is_certain, implements_trait, is_type_diagnostic_item};
 use clippy_utils::visitors::for_each_expr;
@@ -26,11 +28,13 @@ pub(super) fn check<'tcx>(
     name: Symbol,
     receiver: &'tcx hir::Expr<'_>,
     args: &'tcx [hir::Expr<'_>],
+    msrv: Msrv,
 ) {
     /// Checks for `unwrap_or(T::new())`, `unwrap_or(T::default())`,
     /// `or_insert(T::new())` or `or_insert(T::default())`.
     /// Similarly checks for `unwrap_or_else(T::new)`, `unwrap_or_else(T::default)`,
     /// `or_insert_with(T::new)` or `or_insert_with(T::default)`.
+    #[allow(clippy::too_many_arguments)]
     fn check_unwrap_or_default(
         cx: &LateContext<'_>,
         name: Symbol,
@@ -39,7 +43,13 @@ pub(super) fn check<'tcx>(
         call_expr: Option<&hir::Expr<'_>>,
         span: Span,
         method_span: Span,
+        msrv: Msrv,
     ) -> bool {
+        // Don't suggest unwrap_or_default if MSRV is less than 1.16
+        if !msrv.meets(cx, msrvs::STR_REPEAT) {
+            return false;
+        }
+
         if !expr_type_is_certain(cx, receiver) {
             return false;
         }
@@ -55,8 +65,8 @@ pub(super) fn check<'tcx>(
 
         let output_type_implements_default = |fun| {
             let fun_ty = cx.typeck_results().expr_ty(fun);
-            if let ty::FnDef(def_id, args) = fun_ty.kind() {
-                let output_ty = cx.tcx.fn_sig(def_id).instantiate(cx.tcx, args).skip_binder().output();
+            if let ty::FnDef(def_id, substs) = fun_ty.kind() {
+                let output_ty = cx.tcx.fn_sig(def_id).instantiate(cx.tcx, substs).skip_binder().output();
                 cx.tcx
                     .get_diagnostic_item(sym::Default)
                     .is_some_and(|default_trait_id| implements_trait(cx, output_ty, default_trait_id, &[]))
@@ -215,11 +225,11 @@ pub(super) fn check<'tcx>(
                     };
                     (!inner_fun_has_args
                         && !is_nested_expr
-                        && check_unwrap_or_default(cx, name, receiver, fun, Some(ex), expr.span, method_span))
+                        && check_unwrap_or_default(cx, name, receiver, fun, Some(ex), expr.span, method_span, msrv))
                         || check_or_fn_call(cx, name, method_span, receiver, arg, None, expr.span, fun_span)
                 },
                 hir::ExprKind::Path(..) | hir::ExprKind::Closure(..) if !is_nested_expr => {
-                    check_unwrap_or_default(cx, name, receiver, ex, None, expr.span, method_span)
+                    check_unwrap_or_default(cx, name, receiver, ex, None, expr.span, method_span, msrv)
                 },
                 hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
                     check_or_fn_call(cx, name, method_span, receiver, arg, None, expr.span, None)