allow needless_option_take to report for more cases (#13684)

changelog:
```
changelog: [`needless_option_take`]: now lints for all temporary expressions of type  Option<T>.
```

fixes #13671

In general, needless_option_take should report whenever take() is called
on a temporary value, not just when the temporary value is created by
as_ref().

Also, we stop emitting machine applicable fixes in these cases, since
sometimes the intention of the user is to actually clear the original
option, in cases such as `option.as_mut().take()`.

clippy_lints/src/methods/needless_option_take.rs

@@ -1,9 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::match_def_path;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::ty::is_type_diagnostic_item;
-use rustc_errors::Applicability;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -11,20 +8,17 @@ use super::NEEDLESS_OPTION_TAKE;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) {
     // Checks if expression type is equal to sym::Option and if the expr is not a syntactic place
-    if !recv.is_syntactic_place_expr() && is_expr_option(cx, recv) && has_expr_as_ref_path(cx, recv) {
-        let mut applicability = Applicability::MachineApplicable;
-        span_lint_and_sugg(
-            cx,
-            NEEDLESS_OPTION_TAKE,
-            expr.span,
-            "called `Option::take()` on a temporary value",
-            "try",
-            format!(
-                "{}",
-                snippet_with_applicability(cx, recv.span, "..", &mut applicability)
-            ),
-            applicability,
-        );
+    if !recv.is_syntactic_place_expr() && is_expr_option(cx, recv) {
+        if let Some(function_name) = source_of_temporary_value(recv) {
+            span_lint_and_note(
+                cx,
+                NEEDLESS_OPTION_TAKE,
+                expr.span,
+                "called `Option::take()` on a temporary value",
+                None,
+                format!("`{function_name}` creates a temporary value, so calling take() has no effect"),
+            );
+        }
     }
 }
 
@@ -33,9 +27,24 @@ fn is_expr_option(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     is_type_diagnostic_item(cx, expr_type, sym::Option)
 }
 
-fn has_expr_as_ref_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(ref_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
-        return match_def_path(cx, ref_id, &["core", "option", "Option", "as_ref"]);
+/// Returns the string of the function call that creates the temporary.
+/// When this function is called, we are reasonably certain that the `ExprKind` is either
+/// `Call` or `MethodCall` because we already checked that the expression is not
+/// `is_syntactic_place_expr()`.
+fn source_of_temporary_value<'a>(expr: &'a Expr<'_>) -> Option<&'a str> {
+    match expr.peel_borrows().kind {
+        ExprKind::Call(function, _) => {
+            if let ExprKind::Path(QPath::Resolved(_, func_path)) = function.kind {
+                if !func_path.segments.is_empty() {
+                    return Some(func_path.segments[0].ident.name.as_str());
+                }
+            }
+            if let ExprKind::Path(QPath::TypeRelative(_, func_path_segment)) = function.kind {
+                return Some(func_path_segment.ident.name.as_str());
+            }
+            None
+        },
+        ExprKind::MethodCall(path_segment, ..) => Some(path_segment.ident.name.as_str()),
+        _ => None,
     }
-    false
 }