Implement dummy defines attribute that can only avoid adding anything from the signature to the list of opaques that are being defined

Author: oli-obk

compiler/rustc_feature/src/builtin_attrs.rs

@@ -578,6 +578,13 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::No, coroutines, experimental!(coroutines)
     ),
 
+    // `#[defines]` attribute to be applied to functions can and must define hidden types for
+    // the opaque types specified in the attribute.
+    gated!(
+        defines, Normal, template!(List: r#"path::to::Alias, OtherAlias"#), ErrorFollowing,
+        EncodeCrossCrate::No, type_alias_impl_trait, experimental!(defines)
+    ),
+
     // `#[pointee]` attribute to designate the pointee type in SmartPointer derive-macro
     gated!(
         pointee, Normal, template!(Word), ErrorFollowing,

compiler/rustc_span/src/symbol.rs

@@ -707,6 +707,7 @@ symbols! {
         default_method_body_is_const,
         default_type_parameter_fallback,
         default_type_params,
+        defines,
         delayed_bug_from_inside_query,
         deny,
         deprecated,

compiler/rustc_ty_utils/src/opaque_types.rs

@@ -7,7 +7,7 @@ use rustc_middle::bug;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::util::{CheckRegions, NotUniqueParam};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
-use rustc_span::Span;
+use rustc_span::{sym, Span};
 use tracing::{instrument, trace};
 
 use crate::errors::{DuplicateArg, NotParam};
@@ -192,6 +192,13 @@ impl<'tcx> OpaqueTypeCollector<'tcx> {
             }
         }
     }
+
+    fn collect_taits_from_defines_attr(&mut self) -> bool {
+        let Some(attr) = self.tcx.get_attr(self.item, sym::defines) else { return false };
+        let attr = attr.get_normal_item();
+        let _defines = attr.meta_kind().unwrap().defines();
+        true
+    }
 }
 
 impl<'tcx> super::sig_types::SpannedTypeVisitor<'tcx> for OpaqueTypeCollector<'tcx> {
@@ -317,7 +324,9 @@ fn opaque_types_defined_by<'tcx>(
     let kind = tcx.def_kind(item);
     trace!(?kind);
     let mut collector = OpaqueTypeCollector::new(tcx, item);
-    super::sig_types::walk_types(tcx, item, &mut collector);
+    if !collector.collect_taits_from_defines_attr() {
+        super::sig_types::walk_types(tcx, item, &mut collector);
+    }
     match kind {
         DefKind::AssocFn
         | DefKind::Fn

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

@@ -4,22 +4,20 @@
 
 #![feature(type_alias_impl_trait)]
 
-mod foo {
-    pub trait Anything {}
-    impl<T> Anything for T {}
-    pub type Input = impl Anything;
+pub trait Anything {}
+impl<T> Anything for T {}
+pub type Input = impl Anything;
 
-    fn bop(_: Input) {
-        super::run(
-            |x: u32| {
-                println!("{x}");
-            },
-            0,
-        );
-    }
+fn bop(_: Input) {
+    run(
+        |x: u32| {
+            println!("{x}");
+        },
+        0,
+    );
 }
-use foo::Input;
 
+#[defines()]
 fn run<F: FnOnce(Input) -> ()>(f: F, i: Input) {
     f(i);
 }