Don't ICE if TAIT-defining fn contains a closure with _ in return type

compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs

@@ -135,10 +135,16 @@ impl TaitConstraintLocator<'_> {
             return;
         }
 
-        if let Some(hir_sig) = self.tcx.hir_node_by_def_id(item_def_id).fn_decl() {
-            if hir_sig.output.get_infer_ret_ty().is_some() {
+        // Function items with `_` in their return type already emit an error, skip any
+        // "non-defining use" errors for them.
+        match self.tcx.hir_node_by_def_id(item_def_id) {
+            Node::TraitItem(TraitItem { kind: hir::TraitItemKind::Fn(fn_sig, _), .. })
+            | Node::ImplItem(ImplItem { kind: hir::ImplItemKind::Fn(fn_sig, _), .. })
+            | Node::Item(Item { kind: hir::ItemKind::Fn(fn_sig, _, _), .. })
+                if fn_sig.decl.output.get_infer_ret_ty().is_some() =>
+            {
                 let guar = self.tcx.dcx().span_delayed_bug(
-                    hir_sig.output.span(),
+                    fn_sig.decl.output.span(),
                     "inferring return types and opaque types do not mix well",
                 );
                 self.found = Some(ty::OpaqueHiddenType {
@@ -147,6 +153,7 @@ impl TaitConstraintLocator<'_> {
                 });
                 return;
             }
+            _ => {}
         }
 
         // Calling `mir_borrowck` can lead to cycle errors through

tests/ui/type-alias-impl-trait/closure_infer.rs

@@ -0,0 +1,35 @@
+// check-pass
+
+// Regression test for an ICE: https://github.com/rust-lang/rust/issues/119916
+
+#![feature(impl_trait_in_assoc_type)]
+#![feature(type_alias_impl_trait)]
+
+// `impl_trait_in_assoc_type` example from the bug report.
+pub trait StreamConsumer {
+    type BarrierStream;
+    fn execute() -> Self::BarrierStream;
+}
+
+pub struct DispatchExecutor;
+
+impl StreamConsumer for DispatchExecutor {
+    type BarrierStream = impl Sized;
+    fn execute() -> Self::BarrierStream {
+        || -> _ {}
+    }
+}
+
+// Functions that constrain TAITs can contain closures with an `_` in the return type.
+type Foo = impl Sized;
+fn foo() -> Foo {
+    || -> _ {}
+}
+
+// The `_` in the closure return type can also be the TAIT itself.
+type Bar = impl Sized;
+fn bar() -> impl FnOnce() -> Bar {
+    || -> _ {}
+}
+
+fn main() {}