fix(or_fun_call): respect MSRV for unwrap_or_default suggestion

The `unwrap_or_default()` method was introduced in Rust 1.16, but the lint was
suggesting it even when the MSRV was set to 1.15 or lower. This change adds an
MSRV check to ensure we only suggest `unwrap_or_default()` when the MSRV is at
least 1.16.

The fix:
1. Adds MSRV check in `check_unwrap_or_default` using `msrvs::STR_REPEAT` (Rust 1.16)
2. Adds MSRV parameter to the `check` function signature
3. Updates the call site to pass the MSRV parameter

Fixes #14876 (unwrap_or_default MSRV issue)

Author: poglesbyg

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

@@ -2,6 +2,7 @@ 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,6 +27,7 @@ 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())`.
@@ -39,7 +41,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;
         }
@@ -215,11 +223,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)