From 1d787830e9a9fd5b69c9e35a730b904728471188 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 22 Jun 2024 18:24:54 -0400
Subject: [PATCH 01/28] WIP: add and_then_then_some lint

---
 CHANGELOG.md                           |   1 +
 clippy_lints/src/and_then_then_some.rs | 165 +++++++++++++++++++++++++
 clippy_lints/src/declared_lints.rs     |   1 +
 clippy_lints/src/lib.rs                |   2 +
 tests/ui/and_then_then_some.fixed      |  15 +++
 tests/ui/and_then_then_some.rs         |  17 +++
 tests/ui/and_then_then_some.stderr     |  13 ++
 7 files changed, 214 insertions(+)
 create mode 100644 clippy_lints/src/and_then_then_some.rs
 create mode 100644 tests/ui/and_then_then_some.fixed
 create mode 100644 tests/ui/and_then_then_some.rs
 create mode 100644 tests/ui/and_then_then_some.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5258cd9f41aa..c424d36e9de7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5199,6 +5199,7 @@ Released 2018-09-13
 [`almost_complete_letter_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_letter_range
 [`almost_complete_range`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_complete_range
 [`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
+[`and_then_then_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#and_then_then_some
 [`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
 [`arc_with_non_send_sync`]: https://rust-lang.github.io/rust-clippy/master/index.html#arc_with_non_send_sync
 [`arithmetic_side_effects`]: https://rust-lang.github.io/rust-clippy/master/index.html#arithmetic_side_effects
diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
new file mode 100644
index 000000000000..cc6092d0bf91
--- /dev/null
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -0,0 +1,165 @@
+// noise reduction, remove before committing!
+#![allow(unused_variables)]
+
+use rustc_errors::Applicability;
+use rustc_hir::*;
+use rustc_hir::def::Res;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::Span;
+use clippy_utils::{match_def_path, fn_def_id};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects usage of `Option::and_then` and `bool::then_some` that could
+	/// be replaced with `Option::filter`.
+	///
+    /// ### Why is this bad?
+	/// Needless complexity, uses recent and uncommon stdlib funtions instead of
+	/// one older function.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// // example code where clippy issues a warning
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// // example code which does not raise clippy warning
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub AND_THEN_THEN_SOME,
+    nursery,
+    "default lint description"
+}
+
+// note: `Option::filter` is older than `bool::then_some`,
+// so no msrv check is required.
+declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
+
+impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
+	fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+		match expr.kind {
+			ExprKind::MethodCall(method_name, selfarg, [ arg ], span) => {
+				//let option_id = cx.tcx.get_diagnostic_item(sym::Option);
+				// TODO: check if type of reciever is diagnostic item Option.
+				let tckr = cx.typeck_results();
+				let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
+				//dbg!(method_name, selfarg, arg);
+				if match_def_path(cx, def_id,
+								  &["core", "option", "Option", "and_then"])
+				{
+					if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
+						//dbg!(predicate);
+						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
+					}
+				}
+			}
+			// TODO: check for call as associated function
+			_ => {},
+		}
+	}
+}
+
+// `|v| X.then_some(v)` -> Some((span"|v|", X))
+fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>)
+							  -> Option<(Span, &'tcx Expr<'tcx>)>
+{
+	match expr.kind {
+		ExprKind::Closure(Closure{
+			fn_decl: FnDecl{ inputs: [ Ty{ hir_id: arg_id, ..} ], .. },
+			body,
+			..
+		}) => {
+			if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) {
+				//dbg!(arg_id);
+				if let Some(body) = peel_closure_body(cx, expr, *arg_id) {
+					Some((cx.tcx.hir().span(*arg_id), body))
+				} else {
+					None
+				}
+			} else {
+				None
+			}
+		},
+		_ => None,
+	}
+}
+
+fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closure_arg_id: HirId) -> Option<&'tcx Expr<'tcx>> {
+
+	//dbg!(cx.tcx.hir_node(closure_arg_id));
+	match expr.kind {
+		ExprKind::Block(_block, _) =>
+		// recurse somehow, maybe lift { x; y.a() } into { x; y }.a()
+			todo!(),
+		ExprKind::MethodCall(_path, selfarg, [ arg ], _span) => {
+			if is_then_some(cx, expr) &&
+				is_local_defined_at(cx, arg, closure_arg_id)
+			{
+				// the argument to then_some is the same as that given to the closure
+				Some(selfarg)
+			} else {
+				None
+			}
+		}
+		ExprKind::Call(func /*@ Expr{ kind: ExprKind::Path(QPath::Resolved(_, Path{ res: Res::Local(local_hid), ..})), ..},*/, [ pred, arg ]) => {
+			//dbg!(func, fn_def_id(cx, expr));
+			//todo!();
+			if is_then_some(cx, func) && dbg!(is_local_defined_at(cx, arg, closure_arg_id)) {
+				//todo!("it worked!!");
+				Some(pred)
+				
+			} else {
+				//todo!("nope");
+				None
+			}
+		}
+		_ => None,
+	}
+}
+
+fn is_local_defined_at<'tcx>(cx: &LateContext<'tcx>, local: &Expr<'_>, arg_hid: HirId) -> bool {
+	//dbg!(local);
+	match local.kind {
+		ExprKind::Path(QPath::Resolved(_, Path{ res: Res::Local(local_hid), .. })) => {
+			// XXX" this is the best way i could find to compare if a local refers to a specific closure argument.
+			if let Node::Pat(Pat{ span: local_span, .. }) = cx.tcx.hir_node(*local_hid) &&
+				let Node::Ty(Ty{ span: arg_span, .. }) = cx.tcx.hir_node(arg_hid) &&
+				local_span == arg_span
+			{
+				true
+			} else {
+				false
+			}		
+		}
+		// is not local at all, so definitly isn't a local defined at the given position
+		_ => false,
+	}
+}
+
+fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
+	let mut appl = Applicability::MachineApplicable;
+	let sugg = format!(
+		"{}.filter(|{}| {})",
+		snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
+		snippet_with_applicability(cx, closure_args, "<ARGS>", &mut appl),
+		snippet_with_applicability(cx, predicate.span, "<PREDICATE>", &mut appl));
+	span_lint_and_sugg(cx, AND_THEN_THEN_SOME, span,
+					   "use of `and_then` + `then_some` is equivelent to `filter`",
+					   "use `Option::filter` instead",
+					   sugg, appl);
+}
+
+fn is_then_some(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+	if let Some(def_id) = fn_def_id(cx, expr) {
+		match_def_path(
+			cx, dbg!(def_id),
+			&["core", "bool", "<impl bool>", "then_some"])
+	} else {
+		//todo!("not type dependent");
+		false
+	}
+}
+
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 0b674a7d7ab3..f3b87a2ce458 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -39,6 +39,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::utils::internal_lints::unsorted_clippy_utils_paths::UNSORTED_CLIPPY_UTILS_PATHS_INFO,
     crate::absolute_paths::ABSOLUTE_PATHS_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
+    crate::and_then_then_some::AND_THEN_THEN_SOME_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
     crate::arc_with_non_send_sync::ARC_WITH_NON_SEND_SYNC_INFO,
     crate::as_conversions::AS_CONVERSIONS_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index 3d40b397ab9b..c2c055ec2356 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -73,6 +73,7 @@ mod renamed_lints;
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absolute_paths;
 mod almost_complete_range;
+mod and_then_then_some;
 mod approx_const;
 mod arc_with_non_send_sync;
 mod as_conversions;
@@ -1178,6 +1179,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(set_contains_or_insert::HashsetInsertAfterContains));
     store.register_early_pass(|| Box::new(byte_char_slices::ByteCharSlice));
     store.register_early_pass(|| Box::new(cfg_not_test::CfgNotTest));
+    store.register_late_pass(|_| Box::new(and_then_then_some::AndThenThenSome));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
new file mode 100644
index 000000000000..17316dfc8663
--- /dev/null
+++ b/tests/ui/and_then_then_some.fixed
@@ -0,0 +1,15 @@
+#![warn(clippy::and_then_then_some)]
+
+fn main() {
+	let x = Some("foo".to_string());
+
+    let _y = x.clone().filter(|v| v.starts_with('f'));
+
+	let ts = bool::then_some;
+	// even if the function is renamed, it should still fire
+	let _z = x.clone().and_then(|v| (ts(v.starts_with('f'), v)));
+	// even if it's called as an associated method with a block body
+	/*let _w = Option::and_then(x, |v: String| {
+		bool::then_some(v.starts_with('f'), v)
+	});*/
+}
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
new file mode 100644
index 000000000000..63707ba798a6
--- /dev/null
+++ b/tests/ui/and_then_then_some.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::and_then_then_some)]
+
+fn main() {
+	let x = Some("foo".to_string());
+
+    //let _y = x.clone().and_then(|v| v.starts_with('f')
+    //    .then_some(v));
+
+	//let ts = bool::then_some;
+	//use std::primative::bool::then_some as ts;
+	// even if the function is renamed, it should still fire
+	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
+	// even if it's called as an associated method with a block body
+	let _w = Option::and_then(x, |v: String| {
+		bool::then_some(v.starts_with('f'), v)
+	});
+}
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
new file mode 100644
index 000000000000..7d36ebba0f72
--- /dev/null
+++ b/tests/ui/and_then_then_some.stderr
@@ -0,0 +1,13 @@
+error: use of `and_then` + `then_some` is equivelent to `filter`
+  --> tests/ui/and_then_then_some.rs:6:14
+   |
+LL |       let _y = x.clone().and_then(|v| v.starts_with('f')
+   |  ______________^
+LL | |         .then_some(v));
+   | |______________________^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
+   |
+   = note: `-D clippy::and-then-then-some` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::and_then_then_some)]`
+
+error: aborting due to 1 previous error
+

From 4bb4f1337e5a05d233a6a7cd760c847870ffb746 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 22 Jun 2024 22:59:53 -0400
Subject: [PATCH 02/28] saftey commit: it kinda works for the basic case

---
 clippy_lints/src/and_then_then_some.rs | 19 +++++++++++++++----
 tests/ui/and_then_then_some.rs         | 11 ++++-------
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index cc6092d0bf91..32ce90cb7994 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -42,15 +42,16 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 	fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
 		match expr.kind {
 			ExprKind::MethodCall(method_name, selfarg, [ arg ], span) => {
+				dbg!(expr);
 				//let option_id = cx.tcx.get_diagnostic_item(sym::Option);
 				// TODO: check if type of reciever is diagnostic item Option.
 				let tckr = cx.typeck_results();
 				let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
 				//dbg!(method_name, selfarg, arg);
-				if match_def_path(cx, def_id,
-								  &["core", "option", "Option", "and_then"])
+				if dbg!(match_def_path(cx, dbg!(def_id),
+								  &["core", "option", "Option", "and_then"]))
 				{
-					if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
+					if let Some((closure_args, predicate)) = dbg!(then_some_closure_arg(cx, arg)) {
 						//dbg!(predicate);
 						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
 					}
@@ -104,7 +105,7 @@ fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closu
 				None
 			}
 		}
-		ExprKind::Call(func /*@ Expr{ kind: ExprKind::Path(QPath::Resolved(_, Path{ res: Res::Local(local_hid), ..})), ..},*/, [ pred, arg ]) => {
+		ExprKind::Call(func, [ pred, arg ]) => {
 			//dbg!(func, fn_def_id(cx, expr));
 			//todo!();
 			if is_then_some(cx, func) && dbg!(is_local_defined_at(cx, arg, closure_arg_id)) {
@@ -163,3 +164,13 @@ fn is_then_some(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 	}
 }
 
+fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+	if let Some(def_id) = fn_def_id(cx, expr) {
+		match_def_path(
+			cx, dbg!(def_id),
+			&["core", "option", "Option", "and_then"])
+	} else {
+		//todo!("not type dependent");
+		false
+	}
+}
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 63707ba798a6..2aac31f77e5e 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -3,15 +3,12 @@
 fn main() {
 	let x = Some("foo".to_string());
 
-    //let _y = x.clone().and_then(|v| v.starts_with('f')
-    //    .then_some(v));
+    let _y = x.clone().and_then(|v| v.starts_with('f')
+        .then_some(v));
 
-	//let ts = bool::then_some;
-	//use std::primative::bool::then_some as ts;
-	// even if the function is renamed, it should still fire
-	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
+	/*let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
 	// even if it's called as an associated method with a block body
 	let _w = Option::and_then(x, |v: String| {
 		bool::then_some(v.starts_with('f'), v)
-	});
+	});*/
 }

From 5b520b6afd2593a3fbb1cb29143f70cd87d20870 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 22 Jun 2024 23:41:23 -0400
Subject: [PATCH 03/28] handle another edge case

---
 clippy_lints/src/and_then_then_some.rs | 22 ++++++++++------------
 tests/ui/and_then_then_some.rs         |  5 ++---
 2 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 32ce90cb7994..f0ad40354829 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -42,14 +42,13 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 	fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
 		match expr.kind {
 			ExprKind::MethodCall(method_name, selfarg, [ arg ], span) => {
-				dbg!(expr);
+				//(expr);
 				//let option_id = cx.tcx.get_diagnostic_item(sym::Option);
 				// TODO: check if type of reciever is diagnostic item Option.
-				let tckr = cx.typeck_results();
-				let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
+				//let tckr = cx.typeck_results();
+				//let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
 				//dbg!(method_name, selfarg, arg);
-				if dbg!(match_def_path(cx, dbg!(def_id),
-								  &["core", "option", "Option", "and_then"]))
+				if is_and_then(cx, expr)
 				{
 					if let Some((closure_args, predicate)) = dbg!(then_some_closure_arg(cx, arg)) {
 						//dbg!(predicate);
@@ -108,7 +107,7 @@ fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closu
 		ExprKind::Call(func, [ pred, arg ]) => {
 			//dbg!(func, fn_def_id(cx, expr));
 			//todo!();
-			if is_then_some(cx, func) && dbg!(is_local_defined_at(cx, arg, closure_arg_id)) {
+			if dbg!(is_then_some(cx, expr)) && dbg!(is_local_defined_at(cx, arg, closure_arg_id)) {
 				//todo!("it worked!!");
 				Some(pred)
 				
@@ -155,22 +154,21 @@ fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args:
 
 fn is_then_some(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 	if let Some(def_id) = fn_def_id(cx, expr) {
-		match_def_path(
+		dbg!(match_def_path(
 			cx, dbg!(def_id),
-			&["core", "bool", "<impl bool>", "then_some"])
+			&["core", "bool", "<impl bool>", "then_some"]))
 	} else {
-		//todo!("not type dependent");
+		dbg!(expr);
 		false
 	}
 }
 
 fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 	if let Some(def_id) = fn_def_id(cx, expr) {
-		match_def_path(
+		dbg!(match_def_path(
 			cx, dbg!(def_id),
-			&["core", "option", "Option", "and_then"])
+			&["core", "option", "Option", "and_then"]))
 	} else {
-		//todo!("not type dependent");
 		false
 	}
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 2aac31f77e5e..de72ea6e0e31 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -6,9 +6,8 @@ fn main() {
     let _y = x.clone().and_then(|v| v.starts_with('f')
         .then_some(v));
 
-	/*let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
-	// even if it's called as an associated method with a block body
+	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
 	let _w = Option::and_then(x, |v: String| {
 		bool::then_some(v.starts_with('f'), v)
-	});*/
+	});
 }

From 37e70589c0ed7cfa8370579436c1a5ae7eba48ab Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 23 Jun 2024 00:55:28 -0400
Subject: [PATCH 04/28] i think i have everything working

---
 clippy_lints/src/and_then_then_some.rs | 40 ++++++++++++++++++--------
 tests/ui/and_then_then_some.rs         |  6 ++--
 2 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index f0ad40354829..ad41ebdc1343 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -41,7 +41,7 @@ declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
 impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 	fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
 		match expr.kind {
-			ExprKind::MethodCall(method_name, selfarg, [ arg ], span) => {
+			ExprKind::MethodCall(method_name, selfarg, [ arg ], _span) => {
 				//(expr);
 				//let option_id = cx.tcx.get_diagnostic_item(sym::Option);
 				// TODO: check if type of reciever is diagnostic item Option.
@@ -56,6 +56,14 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 					}
 				}
 			}
+			ExprKind::Call(_func, [ selfarg, arg ]) => {
+				if dbg!(is_and_then(cx, expr)) {
+					if let Some((closure_args, predicate)) = dbg!(then_some_closure_arg(cx, arg)) {
+						//dbg!(predicate);
+						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
+					}
+				}
+			}
 			// TODO: check for call as associated function
 			_ => {},
 		}
@@ -66,15 +74,16 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>)
 							  -> Option<(Span, &'tcx Expr<'tcx>)>
 {
+	dbg!(expr);
 	match expr.kind {
 		ExprKind::Closure(Closure{
 			fn_decl: FnDecl{ inputs: [ Ty{ hir_id: arg_id, ..} ], .. },
 			body,
 			..
 		}) => {
-			if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) {
+			if let Node::Expr(expr) = dbg!(cx.tcx.hir_node(body.hir_id)) {
 				//dbg!(arg_id);
-				if let Some(body) = peel_closure_body(cx, expr, *arg_id) {
+				if let Some(body) = dbg!(peel_closure_body(cx, expr, *arg_id)) {
 					Some((cx.tcx.hir().span(*arg_id), body))
 				} else {
 					None
@@ -89,11 +98,11 @@ fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>)
 
 fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closure_arg_id: HirId) -> Option<&'tcx Expr<'tcx>> {
 
-	//dbg!(cx.tcx.hir_node(closure_arg_id));
 	match expr.kind {
-		ExprKind::Block(_block, _) =>
-		// recurse somehow, maybe lift { x; y.a() } into { x; y }.a()
-			todo!(),
+		// it would be nice if we could lift { x; y.a() } into { x; y }.a()
+		ExprKind::Block(Block{ stmts: [], expr: Some(wrapped_expr), ..}, _) => {
+			peel_closure_body(cx, wrapped_expr, closure_arg_id)
+		}
 		ExprKind::MethodCall(_path, selfarg, [ arg ], _span) => {
 			if is_then_some(cx, expr) &&
 				is_local_defined_at(cx, arg, closure_arg_id)
@@ -116,17 +125,24 @@ fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closu
 				None
 			}
 		}
-		_ => None,
+		_ => {
+			eprintln!("cannot peel {expr:#?}");
+			None
+		}
 	}
 }
 
 fn is_local_defined_at<'tcx>(cx: &LateContext<'tcx>, local: &Expr<'_>, arg_hid: HirId) -> bool {
-	//dbg!(local);
+	dbg!(local);
 	match local.kind {
 		ExprKind::Path(QPath::Resolved(_, Path{ res: Res::Local(local_hid), .. })) => {
-			// XXX" this is the best way i could find to compare if a local refers to a specific closure argument.
-			if let Node::Pat(Pat{ span: local_span, .. }) = cx.tcx.hir_node(*local_hid) &&
-				let Node::Ty(Ty{ span: arg_span, .. }) = cx.tcx.hir_node(arg_hid) &&
+			// FIXME: this is the best way i could find to compare if
+			// a local refers to a specific closure argument.
+			//
+			// it breaks if the closure argument has an explicitly declared type,
+			// since the spans only align for TyKind::Infer
+			if let Node::Pat(Pat{ span: local_span, .. }) = dbg!(cx.tcx.hir_node(*local_hid)) &&
+				let Node::Ty(Ty{ span: arg_span, .. }) = dbg!(cx.tcx.hir_node(arg_hid)) &&
 				local_span == arg_span
 			{
 				true
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index de72ea6e0e31..fa855f48e912 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -3,11 +3,11 @@
 fn main() {
 	let x = Some("foo".to_string());
 
-    let _y = x.clone().and_then(|v| v.starts_with('f')
+    /*let _y = x.clone().and_then(|v| v.starts_with('f')
         .then_some(v));
 
-	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
-	let _w = Option::and_then(x, |v: String| {
+	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));*/
+	let _w = Option::and_then(x, |v| {
 		bool::then_some(v.starts_with('f'), v)
 	});
 }

From 3b9bba4a8e09ecb9b0388348ae1177648d98a7fd Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 23 Jun 2024 01:03:31 -0400
Subject: [PATCH 05/28] cover most edge cases

---
 tests/ui/and_then_then_some.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index fa855f48e912..8be2be7768df 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -3,10 +3,10 @@
 fn main() {
 	let x = Some("foo".to_string());
 
-    /*let _y = x.clone().and_then(|v| v.starts_with('f')
+    let _y = x.clone().and_then(|v| v.starts_with('f')
         .then_some(v));
 
-	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));*/
+	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
 	let _w = Option::and_then(x, |v| {
 		bool::then_some(v.starts_with('f'), v)
 	});

From 7a0adc4580db1889eea6aa09e19a42d5b321c417 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 23 Jun 2024 01:11:18 -0400
Subject: [PATCH 06/28] working ui test

---
 clippy_lints/src/and_then_then_some.rs | 42 +++++++++++---------------
 tests/ui/and_then_then_some.fixed      |  9 ++----
 tests/ui/and_then_then_some.stderr     | 17 ++++++++++-
 3 files changed, 36 insertions(+), 32 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index ad41ebdc1343..0bd93318a13c 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -47,19 +47,19 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 				// TODO: check if type of reciever is diagnostic item Option.
 				//let tckr = cx.typeck_results();
 				//let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
-				//dbg!(method_name, selfarg, arg);
+				//(method_name, selfarg, arg);
 				if is_and_then(cx, expr)
 				{
-					if let Some((closure_args, predicate)) = dbg!(then_some_closure_arg(cx, arg)) {
-						//dbg!(predicate);
+					if let Some((closure_args, predicate)) = (then_some_closure_arg(cx, arg)) {
+						//(predicate);
 						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
 					}
 				}
 			}
 			ExprKind::Call(_func, [ selfarg, arg ]) => {
-				if dbg!(is_and_then(cx, expr)) {
-					if let Some((closure_args, predicate)) = dbg!(then_some_closure_arg(cx, arg)) {
-						//dbg!(predicate);
+				if (is_and_then(cx, expr)) {
+					if let Some((closure_args, predicate)) = (then_some_closure_arg(cx, arg)) {
+						//(predicate);
 						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
 					}
 				}
@@ -74,16 +74,16 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>)
 							  -> Option<(Span, &'tcx Expr<'tcx>)>
 {
-	dbg!(expr);
+	(expr);
 	match expr.kind {
 		ExprKind::Closure(Closure{
 			fn_decl: FnDecl{ inputs: [ Ty{ hir_id: arg_id, ..} ], .. },
 			body,
 			..
 		}) => {
-			if let Node::Expr(expr) = dbg!(cx.tcx.hir_node(body.hir_id)) {
-				//dbg!(arg_id);
-				if let Some(body) = dbg!(peel_closure_body(cx, expr, *arg_id)) {
+			if let Node::Expr(expr) = (cx.tcx.hir_node(body.hir_id)) {
+				//(arg_id);
+				if let Some(body) = (peel_closure_body(cx, expr, *arg_id)) {
 					Some((cx.tcx.hir().span(*arg_id), body))
 				} else {
 					None
@@ -114,26 +114,20 @@ fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closu
 			}
 		}
 		ExprKind::Call(func, [ pred, arg ]) => {
-			//dbg!(func, fn_def_id(cx, expr));
-			//todo!();
-			if dbg!(is_then_some(cx, expr)) && dbg!(is_local_defined_at(cx, arg, closure_arg_id)) {
-				//todo!("it worked!!");
+			if (is_then_some(cx, expr)) && (is_local_defined_at(cx, arg, closure_arg_id)) {
 				Some(pred)
 				
 			} else {
-				//todo!("nope");
 				None
 			}
 		}
 		_ => {
-			eprintln!("cannot peel {expr:#?}");
 			None
 		}
 	}
 }
 
 fn is_local_defined_at<'tcx>(cx: &LateContext<'tcx>, local: &Expr<'_>, arg_hid: HirId) -> bool {
-	dbg!(local);
 	match local.kind {
 		ExprKind::Path(QPath::Resolved(_, Path{ res: Res::Local(local_hid), .. })) => {
 			// FIXME: this is the best way i could find to compare if
@@ -141,8 +135,8 @@ fn is_local_defined_at<'tcx>(cx: &LateContext<'tcx>, local: &Expr<'_>, arg_hid:
 			//
 			// it breaks if the closure argument has an explicitly declared type,
 			// since the spans only align for TyKind::Infer
-			if let Node::Pat(Pat{ span: local_span, .. }) = dbg!(cx.tcx.hir_node(*local_hid)) &&
-				let Node::Ty(Ty{ span: arg_span, .. }) = dbg!(cx.tcx.hir_node(arg_hid)) &&
+			if let Node::Pat(Pat{ span: local_span, .. }) = (cx.tcx.hir_node(*local_hid)) &&
+				let Node::Ty(Ty{ span: arg_span, .. }) = (cx.tcx.hir_node(arg_hid)) &&
 				local_span == arg_span
 			{
 				true
@@ -170,19 +164,19 @@ fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args:
 
 fn is_then_some(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 	if let Some(def_id) = fn_def_id(cx, expr) {
-		dbg!(match_def_path(
-			cx, dbg!(def_id),
+		(match_def_path(
+			cx, (def_id),
 			&["core", "bool", "<impl bool>", "then_some"]))
 	} else {
-		dbg!(expr);
+		(expr);
 		false
 	}
 }
 
 fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 	if let Some(def_id) = fn_def_id(cx, expr) {
-		dbg!(match_def_path(
-			cx, dbg!(def_id),
+		(match_def_path(
+			cx, (def_id),
 			&["core", "option", "Option", "and_then"]))
 	} else {
 		false
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 17316dfc8663..068117934a26 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -5,11 +5,6 @@ fn main() {
 
     let _y = x.clone().filter(|v| v.starts_with('f'));
 
-	let ts = bool::then_some;
-	// even if the function is renamed, it should still fire
-	let _z = x.clone().and_then(|v| (ts(v.starts_with('f'), v)));
-	// even if it's called as an associated method with a block body
-	/*let _w = Option::and_then(x, |v: String| {
-		bool::then_some(v.starts_with('f'), v)
-	});*/
+	let _z = x.clone().filter(|v| v.starts_with('f'));
+	let _w = x.filter(|v| v.starts_with('f'));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 7d36ebba0f72..8511deccd203 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -9,5 +9,20 @@ LL | |         .then_some(v));
    = note: `-D clippy::and-then-then-some` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::and_then_then_some)]`
 
-error: aborting due to 1 previous error
+error: use of `and_then` + `then_some` is equivelent to `filter`
+  --> tests/ui/and_then_then_some.rs:9:11
+   |
+LL |     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
+
+error: use of `and_then` + `then_some` is equivelent to `filter`
+  --> tests/ui/and_then_then_some.rs:10:11
+   |
+LL |       let _w = Option::and_then(x, |v| {
+   |  ______________^
+LL | |         bool::then_some(v.starts_with('f'), v)
+LL | |     });
+   | |______^ help: use `Option::filter` instead: `x.filter(|v| v.starts_with('f'))`
+
+error: aborting due to 3 previous errors
 

From 88ec537adc9ab22727b09e65d10012bc2c722543 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 23 Jun 2024 01:24:47 -0400
Subject: [PATCH 07/28] rustfix and rustfmt

---
 clippy_lints/src/and_then_then_some.rs | 272 +++++++++++++------------
 tests/ui/and_then_then_some.fixed      |   6 +-
 tests/ui/and_then_then_some.rs         |  11 +-
 tests/ui/and_then_then_some.stderr     |  17 +-
 4 files changed, 151 insertions(+), 155 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 0bd93318a13c..9ef1db645ec8 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -1,24 +1,24 @@
 // noise reduction, remove before committing!
 #![allow(unused_variables)]
 
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::{fn_def_id, match_def_path};
 use rustc_errors::Applicability;
-use rustc_hir::*;
 use rustc_hir::def::Res;
+use rustc_hir::*;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
-use clippy_utils::{match_def_path, fn_def_id};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_applicability;
 
 declare_clippy_lint! {
     /// ### What it does
     /// Detects usage of `Option::and_then` and `bool::then_some` that could
-	/// be replaced with `Option::filter`.
-	///
+    /// be replaced with `Option::filter`.
+    ///
     /// ### Why is this bad?
-	/// Needless complexity, uses recent and uncommon stdlib funtions instead of
-	/// one older function.
+    /// Needless complexity, uses recent and uncommon stdlib funtions instead of
+    /// one older function.
     ///
     /// ### Example
     /// ```no_run
@@ -39,146 +39,150 @@ declare_clippy_lint! {
 declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
 
 impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
-	fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-		match expr.kind {
-			ExprKind::MethodCall(method_name, selfarg, [ arg ], _span) => {
-				//(expr);
-				//let option_id = cx.tcx.get_diagnostic_item(sym::Option);
-				// TODO: check if type of reciever is diagnostic item Option.
-				//let tckr = cx.typeck_results();
-				//let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
-				//(method_name, selfarg, arg);
-				if is_and_then(cx, expr)
-				{
-					if let Some((closure_args, predicate)) = (then_some_closure_arg(cx, arg)) {
-						//(predicate);
-						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
-					}
-				}
-			}
-			ExprKind::Call(_func, [ selfarg, arg ]) => {
-				if (is_and_then(cx, expr)) {
-					if let Some((closure_args, predicate)) = (then_some_closure_arg(cx, arg)) {
-						//(predicate);
-						show_sugg(cx, expr.span, selfarg, closure_args, predicate);
-					}
-				}
-			}
-			// TODO: check for call as associated function
-			_ => {},
-		}
-	}
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        match expr.kind {
+            ExprKind::MethodCall(method_name, selfarg, [arg], _span) => {
+                //let option_id = cx.tcx.get_diagnostic_item(sym::Option);
+                // TODO: check if type of reciever is diagnostic item Option.
+                //let tckr = cx.typeck_results();
+                //let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
+                //(method_name, selfarg, arg);
+                if is_and_then(cx, expr) {
+                    if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
+                        //(predicate);
+                        show_sugg(cx, expr.span, selfarg, closure_args, predicate);
+                    }
+                }
+            },
+            ExprKind::Call(_func, [selfarg, arg]) => {
+                if is_and_then(cx, expr) {
+                    if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
+                        //(predicate);
+                        show_sugg(cx, expr.span, selfarg, closure_args, predicate);
+                    }
+                }
+            },
+            // TODO: check for call as associated function
+            _ => {},
+        }
+    }
 }
 
 // `|v| X.then_some(v)` -> Some((span"|v|", X))
-fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>)
-							  -> Option<(Span, &'tcx Expr<'tcx>)>
-{
-	(expr);
-	match expr.kind {
-		ExprKind::Closure(Closure{
-			fn_decl: FnDecl{ inputs: [ Ty{ hir_id: arg_id, ..} ], .. },
-			body,
-			..
-		}) => {
-			if let Node::Expr(expr) = (cx.tcx.hir_node(body.hir_id)) {
-				//(arg_id);
-				if let Some(body) = (peel_closure_body(cx, expr, *arg_id)) {
-					Some((cx.tcx.hir().span(*arg_id), body))
-				} else {
-					None
-				}
-			} else {
-				None
-			}
-		},
-		_ => None,
-	}
+fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, &'tcx Expr<'tcx>)> {
+    match expr.kind {
+        ExprKind::Closure(Closure {
+            fn_decl: FnDecl {
+                inputs: [Ty { hir_id: arg_id, .. }],
+                ..
+            },
+            body,
+            ..
+        }) => {
+            if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) {
+                //(arg_id);
+                (peel_closure_body(cx, expr, *arg_id)).map(|body| (cx.tcx.hir().span(*arg_id), body))
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
 }
 
-fn peel_closure_body<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, closure_arg_id: HirId) -> Option<&'tcx Expr<'tcx>> {
-
-	match expr.kind {
-		// it would be nice if we could lift { x; y.a() } into { x; y }.a()
-		ExprKind::Block(Block{ stmts: [], expr: Some(wrapped_expr), ..}, _) => {
-			peel_closure_body(cx, wrapped_expr, closure_arg_id)
-		}
-		ExprKind::MethodCall(_path, selfarg, [ arg ], _span) => {
-			if is_then_some(cx, expr) &&
-				is_local_defined_at(cx, arg, closure_arg_id)
-			{
-				// the argument to then_some is the same as that given to the closure
-				Some(selfarg)
-			} else {
-				None
-			}
-		}
-		ExprKind::Call(func, [ pred, arg ]) => {
-			if (is_then_some(cx, expr)) && (is_local_defined_at(cx, arg, closure_arg_id)) {
-				Some(pred)
-				
-			} else {
-				None
-			}
-		}
-		_ => {
-			None
-		}
-	}
+fn peel_closure_body<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    closure_arg_id: HirId,
+) -> Option<&'tcx Expr<'tcx>> {
+    match expr.kind {
+        // it would be nice if we could lift { x; y.a() } into { x; y }.a()
+        ExprKind::Block(
+            Block {
+                stmts: [],
+                expr: Some(wrapped_expr),
+                ..
+            },
+            _,
+        ) => peel_closure_body(cx, wrapped_expr, closure_arg_id),
+        ExprKind::MethodCall(_path, selfarg, [arg], _span) => {
+            if is_then_some(cx, expr) && is_local_defined_at(cx, arg, closure_arg_id) {
+                // the argument to then_some is the same as that given to the closure
+                Some(selfarg)
+            } else {
+                None
+            }
+        },
+        ExprKind::Call(func, [pred, arg]) => {
+            if (is_then_some(cx, expr)) && (is_local_defined_at(cx, arg, closure_arg_id)) {
+                Some(pred)
+            } else {
+                None
+            }
+        },
+        _ => None,
+    }
 }
 
-fn is_local_defined_at<'tcx>(cx: &LateContext<'tcx>, local: &Expr<'_>, arg_hid: HirId) -> bool {
-	match local.kind {
-		ExprKind::Path(QPath::Resolved(_, Path{ res: Res::Local(local_hid), .. })) => {
-			// FIXME: this is the best way i could find to compare if
-			// a local refers to a specific closure argument.
-			//
-			// it breaks if the closure argument has an explicitly declared type,
-			// since the spans only align for TyKind::Infer
-			if let Node::Pat(Pat{ span: local_span, .. }) = (cx.tcx.hir_node(*local_hid)) &&
-				let Node::Ty(Ty{ span: arg_span, .. }) = (cx.tcx.hir_node(arg_hid)) &&
-				local_span == arg_span
-			{
-				true
-			} else {
-				false
-			}		
-		}
-		// is not local at all, so definitly isn't a local defined at the given position
-		_ => false,
-	}
+fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -> bool {
+    match local.kind {
+        ExprKind::Path(QPath::Resolved(
+            _,
+            Path {
+                res: Res::Local(local_hid),
+                ..
+            },
+        )) => {
+            // FIXME: this is the best way i could find to compare if
+            // a local refers to a specific closure argument.
+            //
+            // it breaks if the closure argument has an explicitly declared type,
+            // since the spans only align for TyKind::Infer
+            if let Node::Pat(Pat { span: local_span, .. }) = (cx.tcx.hir_node(*local_hid))
+                && let Node::Ty(Ty { span: arg_span, .. }) = (cx.tcx.hir_node(arg_hid))
+                && local_span == arg_span
+            {
+                true
+            } else {
+                false
+            }
+        },
+        // is not local at all, so definitly isn't a local defined at the given position
+        _ => false,
+    }
 }
 
 fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
-	let mut appl = Applicability::MachineApplicable;
-	let sugg = format!(
-		"{}.filter(|{}| {})",
-		snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
-		snippet_with_applicability(cx, closure_args, "<ARGS>", &mut appl),
-		snippet_with_applicability(cx, predicate.span, "<PREDICATE>", &mut appl));
-	span_lint_and_sugg(cx, AND_THEN_THEN_SOME, span,
-					   "use of `and_then` + `then_some` is equivelent to `filter`",
-					   "use `Option::filter` instead",
-					   sugg, appl);
+    let mut appl = Applicability::MachineApplicable;
+    let sugg = format!(
+        "{}.filter(|{}| {})",
+        snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
+        snippet_with_applicability(cx, closure_args, "<ARGS>", &mut appl),
+        snippet_with_applicability(cx, predicate.span, "<PREDICATE>", &mut appl)
+    );
+    span_lint_and_sugg(
+        cx,
+        AND_THEN_THEN_SOME,
+        span,
+        "use of `and_then` + `then_some` is equivelent to `filter`",
+        "use `Option::filter` instead",
+        sugg,
+        appl,
+    );
 }
 
 fn is_then_some(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-	if let Some(def_id) = fn_def_id(cx, expr) {
-		(match_def_path(
-			cx, (def_id),
-			&["core", "bool", "<impl bool>", "then_some"]))
-	} else {
-		(expr);
-		false
-	}
+    if let Some(def_id) = fn_def_id(cx, expr) {
+        match_def_path(cx, def_id, &["core", "bool", "<impl bool>", "then_some"])
+    } else {
+        false
+    }
 }
 
 fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-	if let Some(def_id) = fn_def_id(cx, expr) {
-		(match_def_path(
-			cx, (def_id),
-			&["core", "option", "Option", "and_then"]))
-	} else {
-		false
-	}
+    if let Some(def_id) = fn_def_id(cx, expr) {
+        match_def_path(cx, def_id, &["core", "option", "Option", "and_then"])
+    } else {
+        false
+    }
 }
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 068117934a26..5d4b3b0ef8ba 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -1,10 +1,10 @@
 #![warn(clippy::and_then_then_some)]
 
 fn main() {
-	let x = Some("foo".to_string());
+    let x = Some("foo".to_string());
 
     let _y = x.clone().filter(|v| v.starts_with('f'));
 
-	let _z = x.clone().filter(|v| v.starts_with('f'));
-	let _w = x.filter(|v| v.starts_with('f'));
+    let _z = x.clone().filter(|v| v.starts_with('f'));
+    let _w = x.filter(|v| v.starts_with('f'));
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 8be2be7768df..9ffc91779509 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -1,13 +1,10 @@
 #![warn(clippy::and_then_then_some)]
 
 fn main() {
-	let x = Some("foo".to_string());
+    let x = Some("foo".to_string());
 
-    let _y = x.clone().and_then(|v| v.starts_with('f')
-        .then_some(v));
+    let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
 
-	let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
-	let _w = Option::and_then(x, |v| {
-		bool::then_some(v.starts_with('f'), v)
-	});
+    let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
+    let _w = Option::and_then(x, |v| bool::then_some(v.starts_with('f'), v));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 8511deccd203..c698c8d12de2 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -1,28 +1,23 @@
 error: use of `and_then` + `then_some` is equivelent to `filter`
   --> tests/ui/and_then_then_some.rs:6:14
    |
-LL |       let _y = x.clone().and_then(|v| v.starts_with('f')
-   |  ______________^
-LL | |         .then_some(v));
-   | |______________________^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
+LL |     let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
    |
    = note: `-D clippy::and-then-then-some` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::and_then_then_some)]`
 
 error: use of `and_then` + `then_some` is equivelent to `filter`
-  --> tests/ui/and_then_then_some.rs:9:11
+  --> tests/ui/and_then_then_some.rs:8:14
    |
 LL |     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
 
 error: use of `and_then` + `then_some` is equivelent to `filter`
-  --> tests/ui/and_then_then_some.rs:10:11
+  --> tests/ui/and_then_then_some.rs:9:14
    |
-LL |       let _w = Option::and_then(x, |v| {
-   |  ______________^
-LL | |         bool::then_some(v.starts_with('f'), v)
-LL | |     });
-   | |______^ help: use `Option::filter` instead: `x.filter(|v| v.starts_with('f'))`
+LL |     let _w = Option::and_then(x, |v| bool::then_some(v.starts_with('f'), v));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.filter(|v| v.starts_with('f'))`
 
 error: aborting due to 3 previous errors
 

From 5654d3090afb7f6cb977995ef0294bf7d24c71dd Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 23 Jun 2024 01:35:17 -0400
Subject: [PATCH 08/28] cleanup and refactor

---
 clippy_lints/src/and_then_then_some.rs | 43 +++++++-------------------
 1 file changed, 11 insertions(+), 32 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 9ef1db645ec8..407eb9f9eb9a 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -1,6 +1,3 @@
-// noise reduction, remove before committing!
-#![allow(unused_variables)]
-
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{fn_def_id, match_def_path};
@@ -22,16 +19,18 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// // example code where clippy issues a warning
+	/// let x = Some("foo".to_string());
+	/// let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
     /// ```
     /// Use instead:
     /// ```no_run
-    /// // example code which does not raise clippy warning
+	/// let x = Some("foo".to_string());
+    /// let _y = x.clone().filter(|v| v.starts_with('f'));
     /// ```
     #[clippy::version = "1.81.0"]
     pub AND_THEN_THEN_SOME,
     nursery,
-    "default lint description"
+    "detects usage of and_then and then_some that can be replaced by filter"
 }
 
 // note: `Option::filter` is older than `bool::then_some`,
@@ -41,28 +40,16 @@ declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
 impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match expr.kind {
-            ExprKind::MethodCall(method_name, selfarg, [arg], _span) => {
-                //let option_id = cx.tcx.get_diagnostic_item(sym::Option);
-                // TODO: check if type of reciever is diagnostic item Option.
-                //let tckr = cx.typeck_results();
-                //let def_id = tckr.type_dependent_def_id(expr.hir_id).unwrap();
-                //(method_name, selfarg, arg);
+            ExprKind::MethodCall(_, selfarg, [arg], _) |
+			ExprKind::Call(_, [selfarg, arg])
+			=> {
+                // TODO: check if type of reciever is diagnostic item Option?
                 if is_and_then(cx, expr) {
                     if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
-                        //(predicate);
                         show_sugg(cx, expr.span, selfarg, closure_args, predicate);
                     }
                 }
             },
-            ExprKind::Call(_func, [selfarg, arg]) => {
-                if is_and_then(cx, expr) {
-                    if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
-                        //(predicate);
-                        show_sugg(cx, expr.span, selfarg, closure_args, predicate);
-                    }
-                }
-            },
-            // TODO: check for call as associated function
             _ => {},
         }
     }
@@ -80,7 +67,6 @@ fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Opt
             ..
         }) => {
             if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) {
-                //(arg_id);
                 (peel_closure_body(cx, expr, *arg_id)).map(|body| (cx.tcx.hir().span(*arg_id), body))
             } else {
                 None
@@ -105,16 +91,9 @@ fn peel_closure_body<'tcx>(
             },
             _,
         ) => peel_closure_body(cx, wrapped_expr, closure_arg_id),
-        ExprKind::MethodCall(_path, selfarg, [arg], _span) => {
+        ExprKind::MethodCall(_, pred, [arg], _) |
+		ExprKind::Call(_, [pred, arg]) => {
             if is_then_some(cx, expr) && is_local_defined_at(cx, arg, closure_arg_id) {
-                // the argument to then_some is the same as that given to the closure
-                Some(selfarg)
-            } else {
-                None
-            }
-        },
-        ExprKind::Call(func, [pred, arg]) => {
-            if (is_then_some(cx, expr)) && (is_local_defined_at(cx, arg, closure_arg_id)) {
                 Some(pred)
             } else {
                 None

From 7ea79c09abcf3dd6acab0c3c009aade5e727b403 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sun, 23 Jun 2024 02:17:37 -0400
Subject: [PATCH 09/28] remove wildcard import

---
 clippy_lints/src/and_then_then_some.rs | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 407eb9f9eb9a..c3986e8376d8 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{fn_def_id, match_def_path};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::*;
+use rustc_hir::{Block, Closure, Expr, ExprKind, FnDecl, HirId, Node, Pat, Path, QPath, Ty};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -19,12 +19,12 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-	/// let x = Some("foo".to_string());
-	/// let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
+    /// let x = Some("foo".to_string());
+    /// let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
     /// ```
     /// Use instead:
     /// ```no_run
-	/// let x = Some("foo".to_string());
+    /// let x = Some("foo".to_string());
     /// let _y = x.clone().filter(|v| v.starts_with('f'));
     /// ```
     #[clippy::version = "1.81.0"]
@@ -40,9 +40,7 @@ declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
 impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match expr.kind {
-            ExprKind::MethodCall(_, selfarg, [arg], _) |
-			ExprKind::Call(_, [selfarg, arg])
-			=> {
+            ExprKind::MethodCall(_, selfarg, [arg], _) | ExprKind::Call(_, [selfarg, arg]) => {
                 // TODO: check if type of reciever is diagnostic item Option?
                 if is_and_then(cx, expr) {
                     if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
@@ -91,8 +89,7 @@ fn peel_closure_body<'tcx>(
             },
             _,
         ) => peel_closure_body(cx, wrapped_expr, closure_arg_id),
-        ExprKind::MethodCall(_, pred, [arg], _) |
-		ExprKind::Call(_, [pred, arg]) => {
+        ExprKind::MethodCall(_, pred, [arg], _) | ExprKind::Call(_, [pred, arg]) => {
             if is_then_some(cx, expr) && is_local_defined_at(cx, arg, closure_arg_id) {
                 Some(pred)
             } else {

From 2a6f6d0216629f50cc9b1641c98b2ab7cbdfab0a Mon Sep 17 00:00:00 2001
From: lolbinarycat <dogedoge61+github@gmail.com>
Date: Sun, 23 Jun 2024 12:48:35 -0400
Subject: [PATCH 10/28] fix typo

Co-authored-by: John Arundel <john@bitfieldconsulting.com>
---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index c3986e8376d8..7a548d50cdb8 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -14,7 +14,7 @@ declare_clippy_lint! {
     /// be replaced with `Option::filter`.
     ///
     /// ### Why is this bad?
-    /// Needless complexity, uses recent and uncommon stdlib funtions instead of
+    /// Needless complexity, uses recent and uncommon stdlib functions instead of
     /// one older function.
     ///
     /// ### Example

From 360cf82e6a565ca3dc6f7873bf9f74419f58a391 Mon Sep 17 00:00:00 2001
From: lolbinarycat <dogedoge61+github@gmail.com>
Date: Thu, 27 Jun 2024 05:08:25 -0400
Subject: [PATCH 11/28] add backticks around identifiers

Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 7a548d50cdb8..b410879c09cf 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -30,7 +30,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.81.0"]
     pub AND_THEN_THEN_SOME,
     nursery,
-    "detects usage of and_then and then_some that can be replaced by filter"
+    "detects usage of `and_then` and `then_some` that can be replaced by `filter`"
 }
 
 // note: `Option::filter` is older than `bool::then_some`,

From 2ccce8defef523b28fa7cedd9b194776bdb9a40b Mon Sep 17 00:00:00 2001
From: lolbinarycat <dogedoge61+github@gmail.com>
Date: Thu, 27 Jun 2024 05:10:04 -0400
Subject: [PATCH 12/28] adjust variable names

Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index b410879c09cf..4210b66278db 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -40,7 +40,7 @@ declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
 impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         match expr.kind {
-            ExprKind::MethodCall(_, selfarg, [arg], _) | ExprKind::Call(_, [selfarg, arg]) => {
+            ExprKind::MethodCall(_, recv_or_self, [arg], _) | ExprKind::Call(_, [recv_or_self, arg]) => {
                 // TODO: check if type of reciever is diagnostic item Option?
                 if is_and_then(cx, expr) {
                     if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {

From b528cb756f96a5749acc4de8be123b6440ff99c7 Mon Sep 17 00:00:00 2001
From: lolbinarycat <dogedoge61+github@gmail.com>
Date: Thu, 27 Jun 2024 05:11:09 -0400
Subject: [PATCH 13/28] make comment more clear

Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 4210b66278db..4e144c0924ed 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     }
 }
 
-// `|v| X.then_some(v)` -> Some((span"|v|", X))
+// This function returns the span of the closure arguments and the receiver of `then_some` (usually `bool`) if the expression passed is a closure whose single expression is a call to `then_some`.
 fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, &'tcx Expr<'tcx>)> {
     match expr.kind {
         ExprKind::Closure(Closure {

From da89528fdc39854a92a9d3fd8378134d54bc0b10 Mon Sep 17 00:00:00 2001
From: lolbinarycat <dogedoge61+github@gmail.com>
Date: Thu, 27 Jun 2024 05:24:33 -0400
Subject: [PATCH 14/28] reword documentation

Co-authored-by: Catherine Flores <catherine.3.flores@gmail.com>
---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 4e144c0924ed..799bdbb27969 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -140,7 +140,7 @@ fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args:
         cx,
         AND_THEN_THEN_SOME,
         span,
-        "use of `and_then` + `then_some` is equivelent to `filter`",
+        "use of `Option::and_then` and `bool::then_some` is equivelent to `filter`",
         "use `Option::filter` instead",
         sugg,
         appl,

From 8e9fa96fe5bdd713cc7b3c6bb03b6e8ab178a6de Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 05:31:11 -0400
Subject: [PATCH 15/28] run autoformatting

---
 clippy_lints/src/and_then_then_some.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 799bdbb27969..85f5789ead95 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -53,7 +53,8 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     }
 }
 
-// This function returns the span of the closure arguments and the receiver of `then_some` (usually `bool`) if the expression passed is a closure whose single expression is a call to `then_some`.
+// This function returns the span of the closure arguments and the receiver of `then_some` (usually
+// `bool`) if the expression passed is a closure whose single expression is a call to `then_some`.
 fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, &'tcx Expr<'tcx>)> {
     match expr.kind {
         ExprKind::Closure(Closure {

From 13c73611c66889d3e4ea9a1426cbd2ab83c465d7 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 05:36:02 -0400
Subject: [PATCH 16/28] fix variable name

---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 85f5789ead95..3c15336095bc 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
                 // TODO: check if type of reciever is diagnostic item Option?
                 if is_and_then(cx, expr) {
                     if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
-                        show_sugg(cx, expr.span, selfarg, closure_args, predicate);
+                        show_sugg(cx, expr.span, recv_or_self, closure_args, predicate);
                     }
                 }
             },

From 2f343a0dc52b3486987836964126091be74c36a4 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 06:29:12 -0400
Subject: [PATCH 17/28] saftey commit

---
 clippy_lints/src/and_then_then_some.rs | 40 ++++++++++++++------------
 tests/ui/and_then_then_some.fixed      |  2 +-
 tests/ui/and_then_then_some.rs         |  2 +-
 tests/ui/and_then_then_some.stderr     | 10 +++----
 4 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 3c15336095bc..49ea9d12e793 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{fn_def_id, match_def_path};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{Block, Closure, Expr, ExprKind, FnDecl, HirId, Node, Pat, Path, QPath, Ty};
+use rustc_hir::{Block, Closure, Expr, ExprKind, FnDecl, HirId, Node, Pat, Path, QPath, Ty, Param, Body};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -58,14 +58,18 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
 fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, &'tcx Expr<'tcx>)> {
     match expr.kind {
         ExprKind::Closure(Closure {
-            fn_decl: FnDecl {
+            /*fn_decl: FnDecl {
                 inputs: [Ty { hir_id: arg_id, .. }],
                 ..
-            },
+            },*/
             body,
             ..
         }) => {
-            if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) {
+            if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) &&
+				let Body{ params: [ Param{ hir_id: arg_id, .. } ], .. } =
+				cx.tcx.hir().body(*body)
+			{
+				
                 (peel_closure_body(cx, expr, *arg_id)).map(|body| (cx.tcx.hir().span(*arg_id), body))
             } else {
                 None
@@ -101,6 +105,16 @@ fn peel_closure_body<'tcx>(
     }
 }
 
+fn get_pat_hid(node: Node<'_>) -> Option<HirId> {
+	match node {
+		Node::Param(Param{ pat: Pat { hir_id, .. }, .. }) |
+		Node::Pat(Pat{ hir_id, .. }) => Some(*hir_id),
+		_ => {
+			None
+		},
+	}
+}
+
 fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -> bool {
     match local.kind {
         ExprKind::Path(QPath::Resolved(
@@ -110,19 +124,9 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
                 ..
             },
         )) => {
-            // FIXME: this is the best way i could find to compare if
-            // a local refers to a specific closure argument.
-            //
-            // it breaks if the closure argument has an explicitly declared type,
-            // since the spans only align for TyKind::Infer
-            if let Node::Pat(Pat { span: local_span, .. }) = (cx.tcx.hir_node(*local_hid))
-                && let Node::Ty(Ty { span: arg_span, .. }) = (cx.tcx.hir_node(arg_hid))
-                && local_span == arg_span
-            {
-                true
-            } else {
-                false
-            }
+			let local_pat_id = get_pat_hid(cx.tcx.hir_node(*local_hid));
+			local_pat_id.is_some() &&
+				local_pat_id == get_pat_hid(cx.tcx.hir_node(arg_hid))
         },
         // is not local at all, so definitly isn't a local defined at the given position
         _ => false,
@@ -132,7 +136,7 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
 fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
     let mut appl = Applicability::MachineApplicable;
     let sugg = format!(
-        "{}.filter(|{}| {})",
+        "{}.filter(|&{}| {})",
         snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
         snippet_with_applicability(cx, closure_args, "<ARGS>", &mut appl),
         snippet_with_applicability(cx, predicate.span, "<PREDICATE>", &mut appl)
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 5d4b3b0ef8ba..91f2dbc76b93 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -6,5 +6,5 @@ fn main() {
     let _y = x.clone().filter(|v| v.starts_with('f'));
 
     let _z = x.clone().filter(|v| v.starts_with('f'));
-    let _w = x.filter(|v| v.starts_with('f'));
+    let _w = x.filter(|v: String| v.starts_with('f'));
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 9ffc91779509..13d2d6edcf17 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -6,5 +6,5 @@ fn main() {
     let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
 
     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
-    let _w = Option::and_then(x, |v| bool::then_some(v.starts_with('f'), v));
+    let _w = Option::and_then(x, |v: String| bool::then_some(v.starts_with('f'), v));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index c698c8d12de2..e821dbeb99e8 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -1,4 +1,4 @@
-error: use of `and_then` + `then_some` is equivelent to `filter`
+error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
   --> tests/ui/and_then_then_some.rs:6:14
    |
 LL |     let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
@@ -7,17 +7,17 @@ LL |     let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
    = note: `-D clippy::and-then-then-some` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::and_then_then_some)]`
 
-error: use of `and_then` + `then_some` is equivelent to `filter`
+error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
   --> tests/ui/and_then_then_some.rs:8:14
    |
 LL |     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
 
-error: use of `and_then` + `then_some` is equivelent to `filter`
+error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
   --> tests/ui/and_then_then_some.rs:9:14
    |
-LL |     let _w = Option::and_then(x, |v| bool::then_some(v.starts_with('f'), v));
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.filter(|v| v.starts_with('f'))`
+LL |     let _w = Option::and_then(x, |v: String| bool::then_some(v.starts_with('f'), v));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.filter(|v: String| v.starts_with('f'))`
 
 error: aborting due to 3 previous errors
 

From 4e8fe6ce8b5c80916033a047d98fe3cdf14c7e91 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 06:41:08 -0400
Subject: [PATCH 18/28] fix another edge case and add more unit tests

---
 clippy_lints/src/and_then_then_some.rs | 8 +++++---
 tests/ui/and_then_then_some.fixed      | 2 +-
 tests/ui/and_then_then_some.stderr     | 2 +-
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 49ea9d12e793..a7ef9cf8f425 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -66,11 +66,11 @@ fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Opt
             ..
         }) => {
             if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) &&
-				let Body{ params: [ Param{ hir_id: arg_id, .. } ], .. } =
+				let Body{ params: [ Param{ hir_id: arg_id, pat: Pat{ span, .. }, .. } ], .. } =
 				cx.tcx.hir().body(*body)
 			{
 				
-                (peel_closure_body(cx, expr, *arg_id)).map(|body| (cx.tcx.hir().span(*arg_id), body))
+                (peel_closure_body(cx, expr, *arg_id)).map(|body| (*span, body))
             } else {
                 None
             }
@@ -135,8 +135,10 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
 
 fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
     let mut appl = Applicability::MachineApplicable;
+	// FIXME: this relies on deref coertion, which won't work correctly if the predicate involves something
+	// other than a method call.
     let sugg = format!(
-        "{}.filter(|&{}| {})",
+        "{}.filter(|{}| {})",
         snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
         snippet_with_applicability(cx, closure_args, "<ARGS>", &mut appl),
         snippet_with_applicability(cx, predicate.span, "<PREDICATE>", &mut appl)
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 91f2dbc76b93..5d4b3b0ef8ba 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -6,5 +6,5 @@ fn main() {
     let _y = x.clone().filter(|v| v.starts_with('f'));
 
     let _z = x.clone().filter(|v| v.starts_with('f'));
-    let _w = x.filter(|v: String| v.starts_with('f'));
+    let _w = x.filter(|v| v.starts_with('f'));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index e821dbeb99e8..2333cea5b7a0 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -17,7 +17,7 @@ error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
   --> tests/ui/and_then_then_some.rs:9:14
    |
 LL |     let _w = Option::and_then(x, |v: String| bool::then_some(v.starts_with('f'), v));
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.filter(|v: String| v.starts_with('f'))`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.filter(|v| v.starts_with('f'))`
 
 error: aborting due to 3 previous errors
 

From 10901864c6c3bdbf42b86e6823324a537966f3f8 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 07:02:28 -0400
Subject: [PATCH 19/28] add and test another edge case (explicit return)

---
 clippy_lints/src/and_then_then_some.rs |  8 +++++++-
 tests/ui/and_then_then_some.fixed      |  4 +++-
 tests/ui/and_then_then_some.rs         |  4 +++-
 tests/ui/and_then_then_some.stderr     | 12 +++++++++---
 4 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index a7ef9cf8f425..4d8da0275053 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -85,6 +85,10 @@ fn peel_closure_body<'tcx>(
     closure_arg_id: HirId,
 ) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
+		ExprKind::Ret(Some(wrapped_expr)) =>
+		// duplicated blocks because 2023 reference statements are awkward.
+		// "&" peels multiple layers of indirection instead of just one like we want.
+			peel_closure_body(cx, wrapped_expr, closure_arg_id),
         // it would be nice if we could lift { x; y.a() } into { x; y }.a()
         ExprKind::Block(
             Block {
@@ -136,7 +140,9 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
 fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
     let mut appl = Applicability::MachineApplicable;
 	// FIXME: this relies on deref coertion, which won't work correctly if the predicate involves something
-	// other than a method call.
+	// other than a method call.  this is because `and_then` takes an argument by
+	// value, while `filter` takes an argument by reference.
+	
     let sugg = format!(
         "{}.filter(|{}| {})",
         snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 5d4b3b0ef8ba..526d61cfc750 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -6,5 +6,7 @@ fn main() {
     let _y = x.clone().filter(|v| v.starts_with('f'));
 
     let _z = x.clone().filter(|v| v.starts_with('f'));
-    let _w = x.filter(|v| v.starts_with('f'));
+    let _w = x.clone().filter(|v| v.starts_with('f'));
+	#[allow(clippy::needless_return)]
+	let _v = x.clone().filter(|v| v.starts_with('g'));
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 13d2d6edcf17..4fd37821f789 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -6,5 +6,7 @@ fn main() {
     let _y = x.clone().and_then(|v| v.starts_with('f').then_some(v));
 
     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
-    let _w = Option::and_then(x, |v: String| bool::then_some(v.starts_with('f'), v));
+    let _w = Option::and_then(x.clone(), |v: String| bool::then_some(v.starts_with('f'), v));
+	#[allow(clippy::needless_return)]
+	let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 2333cea5b7a0..4c9d373d0d15 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -16,8 +16,14 @@ LL |     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v))
 error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
   --> tests/ui/and_then_then_some.rs:9:14
    |
-LL |     let _w = Option::and_then(x, |v: String| bool::then_some(v.starts_with('f'), v));
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.filter(|v| v.starts_with('f'))`
+LL |     let _w = Option::and_then(x.clone(), |v: String| bool::then_some(v.starts_with('f'), v));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
 
-error: aborting due to 3 previous errors
+error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
+  --> tests/ui/and_then_then_some.rs:11:11
+   |
+LL |     let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('g'))`
+
+error: aborting due to 4 previous errors
 

From de9881f85c1c42653fff48868accab38f6e44bba Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 07:04:41 -0400
Subject: [PATCH 20/28] autoformat

---
 clippy_lints/src/and_then_then_some.rs | 58 +++++++++++++++-----------
 tests/ui/and_then_then_some.rs         |  4 +-
 2 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 4d8da0275053..98133e1de20e 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{fn_def_id, match_def_path};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{Block, Closure, Expr, ExprKind, FnDecl, HirId, Node, Pat, Path, QPath, Ty, Param, Body};
+use rustc_hir::{Block, Body, Closure, Expr, ExprKind, FnDecl, HirId, Node, Param, Pat, Path, QPath, Ty};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
@@ -65,11 +65,19 @@ fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Opt
             body,
             ..
         }) => {
-            if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id) &&
-				let Body{ params: [ Param{ hir_id: arg_id, pat: Pat{ span, .. }, .. } ], .. } =
-				cx.tcx.hir().body(*body)
-			{
-				
+            if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id)
+                && let Body {
+                    params:
+                        [
+                            Param {
+                                hir_id: arg_id,
+                                pat: Pat { span, .. },
+                                ..
+                            },
+                        ],
+                    ..
+                } = cx.tcx.hir().body(*body)
+            {
                 (peel_closure_body(cx, expr, *arg_id)).map(|body| (*span, body))
             } else {
                 None
@@ -85,10 +93,12 @@ fn peel_closure_body<'tcx>(
     closure_arg_id: HirId,
 ) -> Option<&'tcx Expr<'tcx>> {
     match expr.kind {
-		ExprKind::Ret(Some(wrapped_expr)) =>
-		// duplicated blocks because 2023 reference statements are awkward.
-		// "&" peels multiple layers of indirection instead of just one like we want.
-			peel_closure_body(cx, wrapped_expr, closure_arg_id),
+        ExprKind::Ret(Some(wrapped_expr)) =>
+        // duplicated blocks because 2023 reference statements are awkward.
+        // "&" peels multiple layers of indirection instead of just one like we want.
+        {
+            peel_closure_body(cx, wrapped_expr, closure_arg_id)
+        },
         // it would be nice if we could lift { x; y.a() } into { x; y }.a()
         ExprKind::Block(
             Block {
@@ -110,13 +120,14 @@ fn peel_closure_body<'tcx>(
 }
 
 fn get_pat_hid(node: Node<'_>) -> Option<HirId> {
-	match node {
-		Node::Param(Param{ pat: Pat { hir_id, .. }, .. }) |
-		Node::Pat(Pat{ hir_id, .. }) => Some(*hir_id),
-		_ => {
-			None
-		},
-	}
+    match node {
+        Node::Param(Param {
+            pat: Pat { hir_id, .. },
+            ..
+        })
+        | Node::Pat(Pat { hir_id, .. }) => Some(*hir_id),
+        _ => None,
+    }
 }
 
 fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -> bool {
@@ -128,9 +139,8 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
                 ..
             },
         )) => {
-			let local_pat_id = get_pat_hid(cx.tcx.hir_node(*local_hid));
-			local_pat_id.is_some() &&
-				local_pat_id == get_pat_hid(cx.tcx.hir_node(arg_hid))
+            let local_pat_id = get_pat_hid(cx.tcx.hir_node(*local_hid));
+            local_pat_id.is_some() && local_pat_id == get_pat_hid(cx.tcx.hir_node(arg_hid))
         },
         // is not local at all, so definitly isn't a local defined at the given position
         _ => false,
@@ -139,10 +149,10 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
 
 fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
     let mut appl = Applicability::MachineApplicable;
-	// FIXME: this relies on deref coertion, which won't work correctly if the predicate involves something
-	// other than a method call.  this is because `and_then` takes an argument by
-	// value, while `filter` takes an argument by reference.
-	
+    // FIXME: this relies on deref coertion, which won't work correctly if the predicate involves
+    // something other than a method call.  this is because `and_then` takes an argument by
+    // value, while `filter` takes an argument by reference.
+
     let sugg = format!(
         "{}.filter(|{}| {})",
         snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 4fd37821f789..ea388ff1757c 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -7,6 +7,6 @@ fn main() {
 
     let _z = x.clone().and_then(|v| bool::then_some(v.starts_with('f'), v));
     let _w = Option::and_then(x.clone(), |v: String| bool::then_some(v.starts_with('f'), v));
-	#[allow(clippy::needless_return)]
-	let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
+    #[allow(clippy::needless_return)]
+    let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
 }

From 015822d165d3d739ec4ff2a78bebadde1772a6a8 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 10:54:03 -0400
Subject: [PATCH 21/28] remove unused imports

---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 98133e1de20e..8779d08d722c 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{fn_def_id, match_def_path};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::{Block, Body, Closure, Expr, ExprKind, FnDecl, HirId, Node, Param, Pat, Path, QPath, Ty};
+use rustc_hir::{Block, Body, Closure, Expr, ExprKind, HirId, Node, Param, Pat, Path, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;

From be39ee0f231ece2f249ef7832f806221b7730e31 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 27 Jun 2024 11:34:41 -0400
Subject: [PATCH 22/28] update test output

---
 tests/ui/and_then_then_some.fixed  | 4 ++--
 tests/ui/and_then_then_some.stderr | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 526d61cfc750..b77a94dc503b 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -7,6 +7,6 @@ fn main() {
 
     let _z = x.clone().filter(|v| v.starts_with('f'));
     let _w = x.clone().filter(|v| v.starts_with('f'));
-	#[allow(clippy::needless_return)]
-	let _v = x.clone().filter(|v| v.starts_with('g'));
+    #[allow(clippy::needless_return)]
+    let _v = x.clone().filter(|v| v.starts_with('g'));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 4c9d373d0d15..358e7365629d 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -20,7 +20,7 @@ LL |     let _w = Option::and_then(x.clone(), |v: String| bool::then_some(v.star
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('f'))`
 
 error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
-  --> tests/ui/and_then_then_some.rs:11:11
+  --> tests/ui/and_then_then_some.rs:11:14
    |
 LL |     let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('g'))`

From 016653fc677fb7cfb8c2bd3406d171a4bfdab5f9 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 5 Jul 2024 12:03:34 -0400
Subject: [PATCH 23/28] add checks for macros

---
 clippy_lints/src/and_then_then_some.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 8779d08d722c..10039d109354 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -1,10 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{fn_def_id, match_def_path};
+use clippy_utils::{fn_def_id, is_from_proc_macro, match_def_path};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Body, Closure, Expr, ExprKind, HirId, Node, Param, Pat, Path, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::lint::in_external_macro;
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 
@@ -39,11 +40,18 @@ declare_lint_pass!(AndThenThenSome => [AND_THEN_THEN_SOME]);
 
 impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if in_external_macro(cx.tcx.sess, expr.span) {
+            return;
+        }
         match expr.kind {
             ExprKind::MethodCall(_, recv_or_self, [arg], _) | ExprKind::Call(_, [recv_or_self, arg]) => {
                 // TODO: check if type of reciever is diagnostic item Option?
                 if is_and_then(cx, expr) {
                     if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
+                        // this check is expensive, so we do it last.
+                        if is_from_proc_macro(cx, expr) {
+                            return;
+                        }
                         show_sugg(cx, expr.span, recv_or_self, closure_args, predicate);
                     }
                 }

From 6c0607df01d1b883add82ea8a9709db795050eba Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 5 Jul 2024 13:10:48 -0400
Subject: [PATCH 24/28] WIP: add another check to prevent false positives

---
 clippy_lints/src/and_then_then_some.rs | 54 +++++++++++++++++++++-----
 1 file changed, 44 insertions(+), 10 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 10039d109354..704cfef86e75 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{fn_def_id, is_from_proc_macro, match_def_path};
+use clippy_utils::{visitors::for_each_expr, ty::is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Body, Closure, Expr, ExprKind, HirId, Node, Param, Pat, Path, QPath};
@@ -45,14 +46,24 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
         }
         match expr.kind {
             ExprKind::MethodCall(_, recv_or_self, [arg], _) | ExprKind::Call(_, [recv_or_self, arg]) => {
-                // TODO: check if type of reciever is diagnostic item Option?
+                // we could check if type of reciever is diagnostic item Option,
+				// but we don't technically need to, since we're checking the path.
                 if is_and_then(cx, expr) {
-                    if let Some((closure_args, predicate)) = then_some_closure_arg(cx, arg) {
+                    if let Some((closure_arg_hid, closure_arg_span, predicate)) = then_some_closure_arg(cx, arg) {
+						if !contains_only_autoref_of(
+							cx, closure_arg_hid, predicate, false)
+						{
+							// TODO: check if `closure_arg_hid` implements Copy,
+							// if so, show suggestion but with `&` added to the
+							// argument pattern.
+							//cx.typeck_results().expr_ty(
+							return;
+						}
                         // this check is expensive, so we do it last.
                         if is_from_proc_macro(cx, expr) {
                             return;
                         }
-                        show_sugg(cx, expr.span, recv_or_self, closure_args, predicate);
+                        show_sugg(cx, expr.span, recv_or_self, closure_arg_span, predicate);
                     }
                 }
             },
@@ -61,15 +72,11 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     }
 }
 
-// This function returns the span of the closure arguments and the receiver of `then_some` (usually
+// This function returns the span and hir id of the closure arguments and the receiver of `then_some` (usually
 // `bool`) if the expression passed is a closure whose single expression is a call to `then_some`.
-fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, &'tcx Expr<'tcx>)> {
+fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, HirId, &'tcx Expr<'tcx>)> {
     match expr.kind {
         ExprKind::Closure(Closure {
-            /*fn_decl: FnDecl {
-                inputs: [Ty { hir_id: arg_id, .. }],
-                ..
-            },*/
             body,
             ..
         }) => {
@@ -86,7 +93,8 @@ fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Opt
                     ..
                 } = cx.tcx.hir().body(*body)
             {
-                (peel_closure_body(cx, expr, *arg_id)).map(|body| (*span, body))
+                (peel_closure_body(cx, expr, *arg_id))
+					.map(|body| (*span, *arg_id, body))
             } else {
                 None
             }
@@ -193,3 +201,29 @@ fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         false
     }
 }
+
+/// checks that `expr` contains no references to `var` outside of autoref method calls.
+fn contains_only_autoref_of(
+	cx: &LateContext<'_>,
+	var: HirId,
+	expr: &Expr<'_>,
+	in_autoref_call: bool,
+) -> bool {
+	use std::ops::ControlFlow::*;
+	for_each_expr(cx, expr, |subexpr| {
+		if is_local_defined_at(cx, subexpr, var) {
+			match cx.tcx.hir.parent_iter(subexpr.hir_id).next() {
+				Some(ExprKind::MethodCall(_, _, _, _)) => {
+					// TODO: check if type of method reciver has one more level
+					// of indirection than `var`
+					return Continue(());
+				}
+				non_method_call => {
+					dbg!(non_method_call);
+				}
+			}
+			return Break(());
+		}
+		Continue(())
+	}).is_some()
+}

From f03e8d64063462d27928391f44bf37e24bdd7b51 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 5 Jul 2024 13:48:45 -0400
Subject: [PATCH 25/28] add more checks

---
 clippy_lints/src/and_then_then_some.rs | 42 +++++++++++++-------------
 tests/ui/and_then_then_some.fixed      |  5 +++
 tests/ui/and_then_then_some.rs         |  5 +++
 tests/ui/and_then_then_some.stderr     |  8 ++++-
 4 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 704cfef86e75..26fc4b22e083 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -49,21 +49,25 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
                 // we could check if type of reciever is diagnostic item Option,
 				// but we don't technically need to, since we're checking the path.
                 if is_and_then(cx, expr) {
-                    if let Some((closure_arg_hid, closure_arg_span, predicate)) = then_some_closure_arg(cx, arg) {
-						if !contains_only_autoref_of(
-							cx, closure_arg_hid, predicate, false)
+                    if let Some((closure_arg_span, closure_arg_hid, predicate)) = then_some_closure_arg(cx, arg) {
+						let add_ref_pattern;
+						// check if `closure_arg_hid` implements Copy,
+						// if so, show suggestion but with `&` added to the
+						// argument pattern.
+						if is_copy(cx, cx.typeck_results().node_type(closure_arg_hid)) {
+							add_ref_pattern = true;
+						} else if contains_only_autoref_of(
+							cx, closure_arg_hid, predicate)
 						{
-							// TODO: check if `closure_arg_hid` implements Copy,
-							// if so, show suggestion but with `&` added to the
-							// argument pattern.
-							//cx.typeck_results().expr_ty(
+							add_ref_pattern = false;
+						} else {
 							return;
 						}
                         // this check is expensive, so we do it last.
                         if is_from_proc_macro(cx, expr) {
                             return;
                         }
-                        show_sugg(cx, expr.span, recv_or_self, closure_arg_span, predicate);
+                        show_sugg(cx, expr.span, recv_or_self, closure_arg_span, predicate, add_ref_pattern);
                     }
                 }
             },
@@ -163,14 +167,11 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
     }
 }
 
-fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>) {
+fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>, add_ref_pattern: bool) {
     let mut appl = Applicability::MachineApplicable;
-    // FIXME: this relies on deref coertion, which won't work correctly if the predicate involves
-    // something other than a method call.  this is because `and_then` takes an argument by
-    // value, while `filter` takes an argument by reference.
-
+	let prefix = if add_ref_pattern { "&" } else { "" };
     let sugg = format!(
-        "{}.filter(|{}| {})",
+        "{}.filter(|{prefix}{}| {})",
         snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
         snippet_with_applicability(cx, closure_args, "<ARGS>", &mut appl),
         snippet_with_applicability(cx, predicate.span, "<PREDICATE>", &mut appl)
@@ -203,17 +204,16 @@ fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 }
 
 /// checks that `expr` contains no references to `var` outside of autoref method calls.
-fn contains_only_autoref_of(
-	cx: &LateContext<'_>,
+fn contains_only_autoref_of<'tcx>(
+	cx: &LateContext<'tcx>,
 	var: HirId,
-	expr: &Expr<'_>,
-	in_autoref_call: bool,
+	expr: &'tcx Expr<'tcx>,
 ) -> bool {
 	use std::ops::ControlFlow::*;
 	for_each_expr(cx, expr, |subexpr| {
 		if is_local_defined_at(cx, subexpr, var) {
-			match cx.tcx.hir.parent_iter(subexpr.hir_id).next() {
-				Some(ExprKind::MethodCall(_, _, _, _)) => {
+			match cx.tcx.hir().parent_iter(subexpr.hir_id).next() {
+				Some((_hir_id, Node::Expr(Expr{ kind: ExprKind::MethodCall(_, _, _, _), .. }))) => {
 					// TODO: check if type of method reciver has one more level
 					// of indirection than `var`
 					return Continue(());
@@ -225,5 +225,5 @@ fn contains_only_autoref_of(
 			return Break(());
 		}
 		Continue(())
-	}).is_some()
+	}).is_none()
 }
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index b77a94dc503b..5c38562cc824 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -9,4 +9,9 @@ fn main() {
     let _w = x.clone().filter(|v| v.starts_with('f'));
     #[allow(clippy::needless_return)]
     let _v = x.clone().filter(|v| v.starts_with('g'));
+	#[derive(Clone)]
+	struct NonCopy;
+	let a = Some(NonCopy);
+	// non-copy value, but it doesn't appear in the predicate.
+	let _a1 = a.clone().filter(|v| true);
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index ea388ff1757c..9b1f4129ea4f 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -9,4 +9,9 @@ fn main() {
     let _w = Option::and_then(x.clone(), |v: String| bool::then_some(v.starts_with('f'), v));
     #[allow(clippy::needless_return)]
     let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
+	#[derive(Clone)]
+	struct NonCopy;
+	let a = Some(NonCopy);
+	// non-copy value, but it doesn't appear in the predicate.
+	let _a1 = a.clone().and_then(|v| true.then_some(v));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 358e7365629d..8b8a3ba6cd3f 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -25,5 +25,11 @@ error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
 LL |     let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('g'))`
 
-error: aborting due to 4 previous errors
+error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
+  --> tests/ui/and_then_then_some.rs:16:12
+   |
+LL |     let _a1 = a.clone().and_then(|v| true.then_some(v));
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `a.clone().filter(|v| true)`
+
+error: aborting due to 5 previous errors
 

From bb0e265f4daca48a52c83ff458e7719acd812556 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 5 Jul 2024 13:51:01 -0400
Subject: [PATCH 26/28] add extra unit test for the Copy case

---
 tests/ui/and_then_then_some.fixed  | 1 +
 tests/ui/and_then_then_some.rs     | 1 +
 tests/ui/and_then_then_some.stderr | 8 +++++++-
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index 5c38562cc824..ec16c2848266 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -14,4 +14,5 @@ fn main() {
 	let a = Some(NonCopy);
 	// non-copy value, but it doesn't appear in the predicate.
 	let _a1 = a.clone().filter(|v| true);
+	let _ = Some(true).filter(|&v| v);
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index 9b1f4129ea4f..adec496b3e9f 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -14,4 +14,5 @@ fn main() {
 	let a = Some(NonCopy);
 	// non-copy value, but it doesn't appear in the predicate.
 	let _a1 = a.clone().and_then(|v| true.then_some(v));
+	let _ = Some(true).and_then(|v| v.then_some(v));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 8b8a3ba6cd3f..0093b688e8f2 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -31,5 +31,11 @@ error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
 LL |     let _a1 = a.clone().and_then(|v| true.then_some(v));
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `a.clone().filter(|v| true)`
 
-error: aborting due to 5 previous errors
+error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
+  --> tests/ui/and_then_then_some.rs:17:10
+   |
+LL |     let _ = Some(true).and_then(|v| v.then_some(v));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `Some(true).filter(|&v| v)`
+
+error: aborting due to 6 previous errors
 

From c842e4b0e43c9768f683a7cb56bf37a9b249eb9e Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 5 Jul 2024 15:06:44 -0400
Subject: [PATCH 27/28] run autoformatting

---
 clippy_lints/src/and_then_then_some.rs | 109 ++++++++++++++-----------
 tests/ui/and_then_then_some.fixed      |  12 +--
 tests/ui/and_then_then_some.rs         |  12 +--
 tests/ui/and_then_then_some.stderr     |   4 +-
 4 files changed, 75 insertions(+), 62 deletions(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 26fc4b22e083..9e8efe119e1b 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_copy;
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{fn_def_id, is_from_proc_macro, match_def_path};
-use clippy_utils::{visitors::for_each_expr, ty::is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Block, Body, Closure, Expr, ExprKind, HirId, Node, Param, Pat, Path, QPath};
@@ -47,27 +48,32 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
         match expr.kind {
             ExprKind::MethodCall(_, recv_or_self, [arg], _) | ExprKind::Call(_, [recv_or_self, arg]) => {
                 // we could check if type of reciever is diagnostic item Option,
-				// but we don't technically need to, since we're checking the path.
+                // but we don't technically need to, since we're checking the path.
                 if is_and_then(cx, expr) {
                     if let Some((closure_arg_span, closure_arg_hid, predicate)) = then_some_closure_arg(cx, arg) {
-						let add_ref_pattern;
-						// check if `closure_arg_hid` implements Copy,
-						// if so, show suggestion but with `&` added to the
-						// argument pattern.
-						if is_copy(cx, cx.typeck_results().node_type(closure_arg_hid)) {
-							add_ref_pattern = true;
-						} else if contains_only_autoref_of(
-							cx, closure_arg_hid, predicate)
-						{
-							add_ref_pattern = false;
-						} else {
-							return;
-						}
+                        let add_ref_pattern;
+                        // check if `closure_arg_hid` implements Copy,
+                        // if so, show suggestion but with `&` added to the
+                        // argument pattern.
+                        if is_copy(cx, cx.typeck_results().node_type(closure_arg_hid)) {
+                            add_ref_pattern = true;
+                        } else if contains_only_autoref_of(cx, closure_arg_hid, predicate) {
+                            add_ref_pattern = false;
+                        } else {
+                            return;
+                        }
                         // this check is expensive, so we do it last.
                         if is_from_proc_macro(cx, expr) {
                             return;
                         }
-                        show_sugg(cx, expr.span, recv_or_self, closure_arg_span, predicate, add_ref_pattern);
+                        show_sugg(
+                            cx,
+                            expr.span,
+                            recv_or_self,
+                            closure_arg_span,
+                            predicate,
+                            add_ref_pattern,
+                        );
                     }
                 }
             },
@@ -76,14 +82,12 @@ impl<'tcx> LateLintPass<'tcx> for AndThenThenSome {
     }
 }
 
-// This function returns the span and hir id of the closure arguments and the receiver of `then_some` (usually
-// `bool`) if the expression passed is a closure whose single expression is a call to `then_some`.
+// This function returns the span and hir id of the closure arguments and the receiver of
+// `then_some` (usually `bool`) if the expression passed is a closure whose single expression is a
+// call to `then_some`.
 fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(Span, HirId, &'tcx Expr<'tcx>)> {
     match expr.kind {
-        ExprKind::Closure(Closure {
-            body,
-            ..
-        }) => {
+        ExprKind::Closure(Closure { body, .. }) => {
             if let Node::Expr(expr) = cx.tcx.hir_node(body.hir_id)
                 && let Body {
                     params:
@@ -97,8 +101,7 @@ fn then_some_closure_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Opt
                     ..
                 } = cx.tcx.hir().body(*body)
             {
-                (peel_closure_body(cx, expr, *arg_id))
-					.map(|body| (*span, *arg_id, body))
+                (peel_closure_body(cx, expr, *arg_id)).map(|body| (*span, *arg_id, body))
             } else {
                 None
             }
@@ -167,9 +170,16 @@ fn is_local_defined_at(cx: &LateContext<'_>, local: &Expr<'_>, arg_hid: HirId) -
     }
 }
 
-fn show_sugg(cx: &LateContext<'_>, span: Span, selfarg: &Expr<'_>, closure_args: Span, predicate: &Expr<'_>, add_ref_pattern: bool) {
+fn show_sugg(
+    cx: &LateContext<'_>,
+    span: Span,
+    selfarg: &Expr<'_>,
+    closure_args: Span,
+    predicate: &Expr<'_>,
+    add_ref_pattern: bool,
+) {
     let mut appl = Applicability::MachineApplicable;
-	let prefix = if add_ref_pattern { "&" } else { "" };
+    let prefix = if add_ref_pattern { "&" } else { "" };
     let sugg = format!(
         "{}.filter(|{prefix}{}| {})",
         snippet_with_applicability(cx, selfarg.span, "<OPTION>", &mut appl),
@@ -204,26 +214,29 @@ fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 }
 
 /// checks that `expr` contains no references to `var` outside of autoref method calls.
-fn contains_only_autoref_of<'tcx>(
-	cx: &LateContext<'tcx>,
-	var: HirId,
-	expr: &'tcx Expr<'tcx>,
-) -> bool {
-	use std::ops::ControlFlow::*;
-	for_each_expr(cx, expr, |subexpr| {
-		if is_local_defined_at(cx, subexpr, var) {
-			match cx.tcx.hir().parent_iter(subexpr.hir_id).next() {
-				Some((_hir_id, Node::Expr(Expr{ kind: ExprKind::MethodCall(_, _, _, _), .. }))) => {
-					// TODO: check if type of method reciver has one more level
-					// of indirection than `var`
-					return Continue(());
-				}
-				non_method_call => {
-					dbg!(non_method_call);
-				}
-			}
-			return Break(());
-		}
-		Continue(())
-	}).is_none()
+fn contains_only_autoref_of<'tcx>(cx: &LateContext<'tcx>, var: HirId, expr: &'tcx Expr<'tcx>) -> bool {
+    use std::ops::ControlFlow::*;
+    for_each_expr(cx, expr, |subexpr| {
+        if is_local_defined_at(cx, subexpr, var) {
+            match cx.tcx.hir().parent_iter(subexpr.hir_id).next() {
+                Some((
+                    _hir_id,
+                    Node::Expr(Expr {
+                        kind: ExprKind::MethodCall(_, _, _, _),
+                        ..
+                    }),
+                )) => {
+                    // TODO: check if type of method reciver has one more level
+                    // of indirection than `var`
+                    return Continue(());
+                },
+                non_method_call => {
+                    dbg!(non_method_call);
+                },
+            }
+            return Break(());
+        }
+        Continue(())
+    })
+    .is_none()
 }
diff --git a/tests/ui/and_then_then_some.fixed b/tests/ui/and_then_then_some.fixed
index ec16c2848266..bc99d6a173a8 100644
--- a/tests/ui/and_then_then_some.fixed
+++ b/tests/ui/and_then_then_some.fixed
@@ -9,10 +9,10 @@ fn main() {
     let _w = x.clone().filter(|v| v.starts_with('f'));
     #[allow(clippy::needless_return)]
     let _v = x.clone().filter(|v| v.starts_with('g'));
-	#[derive(Clone)]
-	struct NonCopy;
-	let a = Some(NonCopy);
-	// non-copy value, but it doesn't appear in the predicate.
-	let _a1 = a.clone().filter(|v| true);
-	let _ = Some(true).filter(|&v| v);
+    #[derive(Clone)]
+    struct NonCopy;
+    let a = Some(NonCopy);
+    // non-copy value, but it doesn't appear in the predicate.
+    let _a1 = a.clone().filter(|v| true);
+    let _ = Some(true).filter(|&v| v);
 }
diff --git a/tests/ui/and_then_then_some.rs b/tests/ui/and_then_then_some.rs
index adec496b3e9f..f7f5fa41d528 100644
--- a/tests/ui/and_then_then_some.rs
+++ b/tests/ui/and_then_then_some.rs
@@ -9,10 +9,10 @@ fn main() {
     let _w = Option::and_then(x.clone(), |v: String| bool::then_some(v.starts_with('f'), v));
     #[allow(clippy::needless_return)]
     let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v));
-	#[derive(Clone)]
-	struct NonCopy;
-	let a = Some(NonCopy);
-	// non-copy value, but it doesn't appear in the predicate.
-	let _a1 = a.clone().and_then(|v| true.then_some(v));
-	let _ = Some(true).and_then(|v| v.then_some(v));
+    #[derive(Clone)]
+    struct NonCopy;
+    let a = Some(NonCopy);
+    // non-copy value, but it doesn't appear in the predicate.
+    let _a1 = a.clone().and_then(|v| true.then_some(v));
+    let _ = Some(true).and_then(|v| v.then_some(v));
 }
diff --git a/tests/ui/and_then_then_some.stderr b/tests/ui/and_then_then_some.stderr
index 0093b688e8f2..701b5cb02800 100644
--- a/tests/ui/and_then_then_some.stderr
+++ b/tests/ui/and_then_then_some.stderr
@@ -26,13 +26,13 @@ LL |     let _v = x.clone().and_then(|v| return v.starts_with('g').then_some(v))
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `x.clone().filter(|v| v.starts_with('g'))`
 
 error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
-  --> tests/ui/and_then_then_some.rs:16:12
+  --> tests/ui/and_then_then_some.rs:16:15
    |
 LL |     let _a1 = a.clone().and_then(|v| true.then_some(v));
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `a.clone().filter(|v| true)`
 
 error: use of `Option::and_then` and `bool::then_some` is equivelent to `filter`
-  --> tests/ui/and_then_then_some.rs:17:10
+  --> tests/ui/and_then_then_some.rs:17:13
    |
 LL |     let _ = Some(true).and_then(|v| v.then_some(v));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `Option::filter` instead: `Some(true).filter(|&v| v)`

From 122cd11907d927518f5cf56fd354b8f00b36e07d Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 5 Jul 2024 15:38:36 -0400
Subject: [PATCH 28/28] remove glob import

---
 clippy_lints/src/and_then_then_some.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/and_then_then_some.rs b/clippy_lints/src/and_then_then_some.rs
index 9e8efe119e1b..819621fa0fa8 100644
--- a/clippy_lints/src/and_then_then_some.rs
+++ b/clippy_lints/src/and_then_then_some.rs
@@ -215,7 +215,7 @@ fn is_and_then(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 
 /// checks that `expr` contains no references to `var` outside of autoref method calls.
 fn contains_only_autoref_of<'tcx>(cx: &LateContext<'tcx>, var: HirId, expr: &'tcx Expr<'tcx>) -> bool {
-    use std::ops::ControlFlow::*;
+    use std::ops::ControlFlow::{Break, Continue};
     for_each_expr(cx, expr, |subexpr| {
         if is_local_defined_at(cx, subexpr, var) {
             match cx.tcx.hir().parent_iter(subexpr.hir_id).next() {