Fixes #14876

The `manual_unwrap_or` lint was incorrectly suggesting `unwrap_or_default()` when the MSRV was set to 1.15 or lower, even though `unwrap_or_default()` was only stabilized in Rust 1.16.

Changes made:
1. Fixed the MSRV check in `manual_unwrap_or.rs` to use the correct constant `msrvs::UNWRAP_OR_DEFAULT` instead of `msrvs::STR_REPEAT`
2. Added the `UNWRAP_OR_DEFAULT` constant to the MSRV aliases in `msrvs.rs`, marking it as stabilized in Rust 1.16

This ensures that the lint will only suggest using `unwrap_or_default()` when the MSRV is at least 1.16.

changelog: Fix [`manual_unwrap_or`] false positive when MSRV is below 1.16

On branch Fix-`manual_unwrap_or`-lint-to-respect-MSRV-for-`unwrap_or_default()`
Changes to be committed:
	modified:   clippy_lints/src/matches/manual_unwrap_or.rs
	modified:   clippy_lints/src/matches/mod.rs
	modified:   clippy_utils/src/msrvs.rs

Author: poglesbyg

clippy_lints/src/matches/manual_unwrap_or.rs

@@ -1,4 +1,5 @@
 use clippy_utils::consts::ConstEvalCtxt;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{SpanRangeExt as _, indent_of, reindent_multiline};
 use rustc_ast::{BindingMode, ByRef};
 use rustc_errors::Applicability;
@@ -82,6 +83,7 @@ fn handle(
     body_some: &Expr<'_>,
     body_none: &Expr<'_>,
     binding_id: HirId,
+    msrv: Msrv,
 ) {
     // Only deal with situations where both alternatives return the same non-adjusted type.
     if cx.typeck_results().expr_ty(body_some) != cx.typeck_results().expr_ty(body_none) {
@@ -112,6 +114,8 @@ fn handle(
             && let GenericArgKind::Type(condition_ty) = condition_ty.unpack()
             && implements_trait(cx, condition_ty, default_trait_id, &[])
             && is_default_equivalent(cx, peel_blocks(body_none))
+            // Check if MSRV meets the requirement for unwrap_or_default (stabilized in 1.16)
+            && msrv.meets(cx, msrvs::UNWRAP_OR_DEFAULT)
         {
             // We now check if the condition is a None variant, in which case we need to specify the type
             if path_res(cx, condition)
@@ -186,6 +190,7 @@ pub fn check_match<'tcx>(
     expr: &'tcx Expr<'tcx>,
     scrutinee: &'tcx Expr<'tcx>,
     arms: &'tcx [Arm<'tcx>],
+    msrv: Msrv,
 ) {
     if let [arm1, arm2] = arms
         // Make sure there are no guards to keep things simple
@@ -194,7 +199,7 @@ pub fn check_match<'tcx>(
         // Get the some and none bodies and the binding id of the some arm
         && let Some(((body_some, binding_id), body_none)) = get_some_and_none_bodies(cx, arm1, arm2)
     {
-        handle(cx, expr, "match", scrutinee, body_some, body_none, binding_id);
+        handle(cx, expr, "match", scrutinee, body_some, body_none, binding_id, msrv);
     }
 }
 
@@ -205,6 +210,7 @@ pub fn check_if_let<'tcx>(
     scrutinee: &'tcx Expr<'tcx>,
     then_expr: &'tcx Expr<'tcx>,
     else_expr: &'tcx Expr<'tcx>,
+    msrv: Msrv,
 ) {
     if let Some(binding_id) = get_some(cx, pat) {
         handle(
@@ -215,6 +221,7 @@ pub fn check_if_let<'tcx>(
             peel_blocks(then_expr),
             peel_blocks(else_expr),
             binding_id,
+            msrv,
         );
     }
 }

clippy_lints/src/matches/mod.rs

@@ -1062,37 +1062,37 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
             if is_direct_expn_of(expr.span, sym::matches).is_some()
                 && let [arm, _] = arms
             {
-                redundant_pattern_match::check_match(cx, expr, ex, arms);
+                redundant_pattern_match::check_match(cx, expr, ex, &arms);
                 redundant_pattern_match::check_matches_true(cx, expr, arm, ex);
             }
 
             if source == MatchSource::Normal && !is_span_match(cx, expr.span) {
                 return;
             }
             if matches!(source, MatchSource::Normal | MatchSource::ForLoopDesugar) {
-                significant_drop_in_scrutinee::check_match(cx, expr, ex, arms, source);
+                significant_drop_in_scrutinee::check_match(cx, expr, ex, &arms, source);
             }
 
-            collapsible_match::check_match(cx, arms, self.msrv);
+            collapsible_match::check_match(cx, &arms, self.msrv);
             if !from_expansion {
                 // These don't depend on a relationship between multiple arms
-                match_wild_err_arm::check(cx, ex, arms);
-                wild_in_or_pats::check(cx, ex, arms);
+                match_wild_err_arm::check(cx, ex, &arms);
+                wild_in_or_pats::check(cx, ex, &arms);
             }
 
             if let MatchSource::TryDesugar(_) = source {
                 try_err::check(cx, expr, ex);
             }
 
-            if !from_expansion && !contains_cfg_arm(cx, expr, ex, arms) {
+            if !from_expansion && !contains_cfg_arm(cx, expr, ex, &arms) {
                 if source == MatchSource::Normal {
                     if !(self.msrv.meets(cx, msrvs::MATCHES_MACRO)
-                        && match_like_matches::check_match(cx, expr, ex, arms))
+                        && match_like_matches::check_match(cx, expr, ex, &arms))
                     {
-                        match_same_arms::check(cx, arms);
+                        match_same_arms::check(cx, &arms);
                     }
 
-                    redundant_pattern_match::check_match(cx, expr, ex, arms);
+                    redundant_pattern_match::check_match(cx, expr, ex, &arms);
                     let source_map = cx.tcx.sess.source_map();
                     let mut match_comments = span_extract_comments(source_map, expr.span);
                     // We remove comments from inside arms block.
@@ -1112,26 +1112,26 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     }
                     // If there are still comments, it means they are outside of the arms. Tell the lint
                     // code about it.
-                    single_match::check(cx, ex, arms, expr, !match_comments.is_empty());
-                    match_bool::check(cx, ex, arms, expr);
-                    overlapping_arms::check(cx, ex, arms);
-                    match_wild_enum::check(cx, ex, arms);
-                    match_as_ref::check(cx, ex, arms, expr);
-                    needless_match::check_match(cx, ex, arms, expr);
-                    match_str_case_mismatch::check(cx, ex, arms);
-                    redundant_guards::check(cx, arms, self.msrv);
+                    single_match::check(cx, ex, &arms, expr, !match_comments.is_empty());
+                    match_bool::check(cx, ex, &arms, expr);
+                    overlapping_arms::check(cx, ex, &arms);
+                    match_wild_enum::check(cx, ex, &arms);
+                    match_as_ref::check(cx, ex, &arms, expr);
+                    needless_match::check_match(cx, ex, &arms, expr);
+                    match_str_case_mismatch::check(cx, ex, &arms);
+                    redundant_guards::check(cx, &arms, self.msrv);
 
                     if !is_in_const_context(cx) {
-                        manual_unwrap_or::check_match(cx, expr, ex, arms);
-                        manual_map::check_match(cx, expr, ex, arms);
-                        manual_filter::check_match(cx, ex, arms, expr);
-                        manual_ok_err::check_match(cx, expr, ex, arms);
+                        manual_unwrap_or::check_match(cx, expr, ex, &arms, self.msrv);
+                        manual_map::check_match(cx, expr, ex, &arms);
+                        manual_filter::check_match(cx, ex, &arms, expr);
+                        manual_ok_err::check_match(cx, expr, ex, &arms);
                     }
 
                     if self.infallible_destructuring_match_linted {
                         self.infallible_destructuring_match_linted = false;
                     } else {
-                        match_single_binding::check(cx, ex, arms, expr);
+                        match_single_binding::check(cx, ex, &arms, expr);
                     }
                 }
                 match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
@@ -1159,6 +1159,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                             if_let.let_expr,
                             if_let.if_then,
                             else_expr,
+                            self.msrv,
                         );
                         manual_map::check_if_let(cx, expr, if_let.let_pat, if_let.let_expr, if_let.if_then, else_expr);
                         manual_filter::check_if_let(

clippy_utils/src/msrvs.rs

@@ -76,7 +76,7 @@ msrv_aliases! {
     1,24,0 { IS_ASCII_DIGIT }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
-    1,16,0 { STR_REPEAT }
+    1,16,0 { STR_REPEAT, UNWRAP_OR_DEFAULT }
     1,15,0 { MAYBE_BOUND_IN_WHERE }
     1,13,0 { QUESTION_MARK_OPERATOR }
 }