Implement #[defines] attribute for consts and functions.

statics still need work

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_ast/src/ast.rs

@@ -394,6 +394,7 @@ pub struct Generics {
     pub params: ThinVec<GenericParam>,
     pub where_clause: WhereClause,
     pub span: Span,
+    pub define_opaques: Option<ThinVec<(NodeId, Path)>>,
 }
 
 /// A where-clause in a definition.
@@ -1413,6 +1414,7 @@ pub struct Closure {
     pub fn_decl_span: Span,
     /// The span of the argument block `|...|`
     pub fn_arg_span: Span,
+    pub define_opaques: Option<ThinVec<(NodeId, Path)>>,
 }
 
 /// Limit types of a range (inclusive or exclusive).
@@ -3233,6 +3235,30 @@ impl Item {
             ItemKind::Impl(i) => Some(&i.generics),
         }
     }
+
+    pub fn define_opaques(&mut self) -> Option<&mut Option<ThinVec<(NodeId, Path)>>> {
+        match &mut self.kind {
+            ItemKind::ExternCrate(_)
+            | ItemKind::Use(_)
+            | ItemKind::Mod(_, _)
+            | ItemKind::ForeignMod(_)
+            | ItemKind::GlobalAsm(_)
+            | ItemKind::MacCall(_)
+            | ItemKind::Delegation(_)
+            | ItemKind::DelegationMac(_)
+            | ItemKind::MacroDef(_) => None,
+            ItemKind::Static(s) => Some(&mut s.define_opaques),
+            ItemKind::Const(i) => Some(&mut i.generics.define_opaques),
+            ItemKind::Fn(i) => Some(&mut i.generics.define_opaques),
+            ItemKind::TyAlias(i) => Some(&mut i.generics.define_opaques),
+            ItemKind::TraitAlias(generics, _)
+            | ItemKind::Enum(_, generics)
+            | ItemKind::Struct(_, generics)
+            | ItemKind::Union(_, generics) => Some(&mut generics.define_opaques),
+            ItemKind::Trait(i) => Some(&mut i.generics.define_opaques),
+            ItemKind::Impl(i) => Some(&mut i.generics.define_opaques),
+        }
+    }
 }
 
 /// `extern` qualifier on a function item or function type.
@@ -3411,6 +3437,7 @@ pub struct StaticItem {
     pub safety: Safety,
     pub mutability: Mutability,
     pub expr: Option<P<Expr>>,
+    pub define_opaques: Option<ThinVec<(NodeId, Path)>>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]
@@ -3678,15 +3705,15 @@ mod size_asserts {
     static_assert_size!(Block, 32);
     static_assert_size!(Expr, 72);
     static_assert_size!(ExprKind, 40);
-    static_assert_size!(Fn, 168);
+    static_assert_size!(Fn, 176);
     static_assert_size!(ForeignItem, 88);
     static_assert_size!(ForeignItemKind, 16);
     static_assert_size!(GenericArg, 24);
     static_assert_size!(GenericBound, 88);
-    static_assert_size!(Generics, 40);
-    static_assert_size!(Impl, 136);
-    static_assert_size!(Item, 136);
-    static_assert_size!(ItemKind, 64);
+    static_assert_size!(Generics, 48);
+    static_assert_size!(Impl, 144);
+    static_assert_size!(Item, 144);
+    static_assert_size!(ItemKind, 72);
     static_assert_size!(LitKind, 24);
     static_assert_size!(Local, 80);
     static_assert_size!(MetaItemLit, 40);

compiler/rustc_ast/src/mut_visit.rs

@@ -1089,10 +1089,15 @@ fn walk_lifetime<T: MutVisitor>(vis: &mut T, Lifetime { id, ident }: &mut Lifeti
 }
 
 fn walk_generics<T: MutVisitor>(vis: &mut T, generics: &mut Generics) {
-    let Generics { params, where_clause, span } = generics;
+    let Generics { params, where_clause, span, define_opaques } = generics;
     params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
     vis.visit_where_clause(where_clause);
     vis.visit_span(span);
+
+    for (id, path) in define_opaques.iter_mut().flatten() {
+        vis.visit_id(id);
+        vis.visit_path(path)
+    }
 }
 
 fn walk_ty_alias_where_clauses<T: MutVisitor>(vis: &mut T, tawcs: &mut TyAliasWhereClauses) {
@@ -1237,9 +1242,20 @@ impl WalkItemKind for ItemKind {
         match self {
             ItemKind::ExternCrate(_orig_name) => {}
             ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree),
-            ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
+            ItemKind::Static(box StaticItem {
+                ty,
+                safety: _,
+                mutability: _,
+                expr,
+                define_opaques,
+            }) => {
                 vis.visit_ty(ty);
                 visit_opt(expr, |expr| vis.visit_expr(expr));
+
+                for (id, path) in define_opaques.iter_mut().flatten() {
+                    vis.visit_id(id);
+                    vis.visit_path(path)
+                }
             }
             ItemKind::Const(item) => {
                 visit_const_item(item, vis);
@@ -1505,7 +1521,14 @@ impl WalkItemKind for ForeignItemKind {
         visitor: &mut impl MutVisitor,
     ) {
         match self {
-            ForeignItemKind::Static(box StaticItem { ty, mutability: _, expr, safety: _ }) => {
+            ForeignItemKind::Static(box StaticItem {
+                ty,
+                mutability: _,
+                expr,
+                safety: _,
+                define_opaques,
+            }) => {
+                assert!(define_opaques.is_none(), "{define_opaques:#?}");
                 visitor.visit_ty(ty);
                 visit_opt(expr, |expr| visitor.visit_expr(expr));
             }
@@ -1726,12 +1749,17 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             body,
             fn_decl_span,
             fn_arg_span,
+            define_opaques,
         }) => {
             visit_constness(vis, constness);
             vis.visit_capture_by(capture_clause);
             vis.visit_fn(FnKind::Closure(binder, coroutine_kind, fn_decl, body), *span, *id);
             vis.visit_span(fn_decl_span);
             vis.visit_span(fn_arg_span);
+            for (id, path) in define_opaques.iter_mut().flatten() {
+                vis.visit_id(id);
+                vis.visit_path(path)
+            }
         }
         ExprKind::Block(blk, label) => {
             visit_opt(label, |label| vis.visit_label(label));

compiler/rustc_ast/src/visit.rs

@@ -371,9 +371,19 @@ impl WalkItemKind for ItemKind {
         match self {
             ItemKind::ExternCrate(_rename) => {}
             ItemKind::Use(use_tree) => try_visit!(visitor.visit_use_tree(use_tree, id, false)),
-            ItemKind::Static(box StaticItem { ty, safety: _, mutability: _, expr }) => {
+            ItemKind::Static(box StaticItem {
+                ty,
+                safety: _,
+                mutability: _,
+                expr,
+                define_opaques,
+            }) => {
                 try_visit!(visitor.visit_ty(ty));
                 visit_opt!(visitor, visit_expr, expr);
+
+                for (id, path) in define_opaques.iter().flatten() {
+                    try_visit!(visitor.visit_path(path, *id))
+                }
             }
             ItemKind::Const(box ConstItem { defaultness: _, generics, ty, expr }) => {
                 try_visit!(visitor.visit_generics(generics));
@@ -729,9 +739,18 @@ impl WalkItemKind for ForeignItemKind {
         visitor: &mut V,
     ) -> V::Result {
         match self {
-            ForeignItemKind::Static(box StaticItem { ty, mutability: _, expr, safety: _ }) => {
+            ForeignItemKind::Static(box StaticItem {
+                ty,
+                mutability: _,
+                expr,
+                safety: _,
+                define_opaques,
+            }) => {
                 try_visit!(visitor.visit_ty(ty));
                 visit_opt!(visitor, visit_expr, expr);
+                for (id, path) in define_opaques.iter().flatten() {
+                    try_visit!(visitor.visit_path(path, *id))
+                }
             }
             ForeignItemKind::Fn(func) => {
                 let kind = FnKind::Fn(FnCtxt::Foreign, ident, vis, &*func);
@@ -798,10 +817,14 @@ pub fn walk_generic_param<'a, V: Visitor<'a>>(
 }
 
 pub fn walk_generics<'a, V: Visitor<'a>>(visitor: &mut V, generics: &'a Generics) -> V::Result {
-    let Generics { params, where_clause, span: _ } = generics;
+    let Generics { params, where_clause, span: _, define_opaques } = generics;
     let WhereClause { has_where_token: _, predicates, span: _ } = where_clause;
     walk_list!(visitor, visit_generic_param, params);
     walk_list!(visitor, visit_where_predicate, predicates);
+
+    for (id, path) in define_opaques.iter().flatten() {
+        try_visit!(visitor.visit_path(path, *id))
+    }
     V::Result::output()
 }
 
@@ -1196,13 +1219,17 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) -> V
             body,
             fn_decl_span: _,
             fn_arg_span: _,
+            define_opaques,
         }) => {
             try_visit!(visitor.visit_capture_by(capture_clause));
             try_visit!(visitor.visit_fn(
                 FnKind::Closure(binder, coroutine_kind, fn_decl, body),
                 *span,
                 *id
-            ))
+            ));
+            for (id, path) in define_opaques.iter().flatten() {
+                try_visit!(visitor.visit_path(path, *id))
+            }
         }
         ExprKind::Block(block, opt_label) => {
             visit_opt!(visitor, visit_label, opt_label);

compiler/rustc_ast_lowering/src/delegation.rs

@@ -131,6 +131,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             has_where_clause_predicates: false,
             where_clause_span: span,
             span,
+            define_opaques: None,
         })
     }
 

compiler/rustc_ast_lowering/src/expr.rs

@@ -217,6 +217,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     body,
                     fn_decl_span,
                     fn_arg_span,
+                    define_opaques,
                 }) => match coroutine_kind {
                     Some(coroutine_kind) => self.lower_expr_coroutine_closure(
                         binder,
@@ -228,6 +229,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         body,
                         *fn_decl_span,
                         *fn_arg_span,
+                        define_opaques,
                     ),
                     None => self.lower_expr_closure(
                         binder,
@@ -240,6 +242,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         body,
                         *fn_decl_span,
                         *fn_arg_span,
+                        define_opaques,
                     ),
                 },
                 ExprKind::Gen(capture_clause, block, genblock_kind, decl_span) => {
@@ -807,6 +810,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             fn_arg_span: None,
             kind: hir::ClosureKind::Coroutine(coroutine_kind),
             constness: hir::Constness::NotConst,
+            // FIXME(type_alias_impl_trait): generators should also be able to have the attribute
+            define_opaques: None,
         }))
     }
 
@@ -1076,6 +1081,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Expr,
         fn_decl_span: Span,
         fn_arg_span: Span,
+        define_opaques: &Option<ThinVec<(NodeId, Path)>>,
     ) -> hir::ExprKind<'hir> {
         let closure_def_id = self.local_def_id(closure_id);
         let (binder_clause, generic_params) = self.lower_closure_binder(binder);
@@ -1105,8 +1111,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let bound_generic_params = self.lower_lifetime_binder(closure_id, generic_params);
         // Lower outside new scope to preserve `is_in_loop_condition`.
         let fn_decl = self.lower_fn_decl(decl, closure_id, fn_decl_span, FnDeclKind::Closure, None);
+        let define_opaques = self.lower_define_opaques(define_opaques);
 
         let c = self.arena.alloc(hir::Closure {
+            define_opaques,
             def_id: closure_def_id,
             binder: binder_clause,
             capture_clause,
@@ -1178,6 +1186,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Expr,
         fn_decl_span: Span,
         fn_arg_span: Span,
+        define_opaques: &Option<ThinVec<(NodeId, Path)>>,
     ) -> hir::ExprKind<'hir> {
         let closure_def_id = self.local_def_id(closure_id);
         let (binder_clause, generic_params) = self.lower_closure_binder(binder);
@@ -1217,8 +1226,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // closure argument types.
         let fn_decl =
             self.lower_fn_decl(&decl, closure_id, fn_decl_span, FnDeclKind::Closure, None);
+        let define_opaques = self.lower_define_opaques(define_opaques);
 
         let c = self.arena.alloc(hir::Closure {
+            define_opaques,
             def_id: closure_def_id,
             binder: binder_clause,
             capture_clause,

compiler/rustc_ast_lowering/src/item.rs

@@ -188,10 +188,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 self.lower_use_tree(use_tree, &prefix, id, vis_span, ident, attrs)
             }
-            ItemKind::Static(box ast::StaticItem { ty: t, safety: _, mutability: m, expr: e }) => {
+            ItemKind::Static(box ast::StaticItem {
+                ty: t,
+                safety: _,
+                mutability: m,
+                expr: e,
+                define_opaques,
+            }) => {
                 let (ty, body_id) =
                     self.lower_const_item(t, span, e.as_deref(), ImplTraitPosition::StaticTy);
-                hir::ItemKind::Static(ty, *m, body_id)
+
+                let define_opaques = self.lower_define_opaques(define_opaques);
+                hir::ItemKind::Static(ty, *m, body_id, define_opaques)
             }
             ItemKind::Const(box ast::ConstItem { generics, ty, expr, .. }) => {
                 let (generics, (ty, body_id)) = self.lower_generics(
@@ -209,7 +217,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 generics,
                 body,
                 contract,
-                ..
+                defaultness: _,
             }) => {
                 self.with_new_scopes(*fn_sig_span, |this| {
                     // Note: we don't need to change the return type from `T` to
@@ -653,10 +661,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         generics,
                     )
                 }
-                ForeignItemKind::Static(box StaticItem { ty, mutability, expr: _, safety }) => {
+                ForeignItemKind::Static(box StaticItem {
+                    ty,
+                    mutability,
+                    expr: _,
+                    safety,
+                    define_opaques,
+                }) => {
                     let ty = self
                         .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
                     let safety = self.lower_safety(*safety, hir::Safety::Unsafe);
+                    assert!(define_opaques.is_none());
 
                     hir::ForeignItemKind::Static(ty, *mutability, safety)
                 }
@@ -1646,17 +1661,40 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds);
         predicates.extend(impl_trait_bounds.into_iter());
 
+        let define_opaques = self.lower_define_opaques(&generics.define_opaques);
+
         let lowered_generics = self.arena.alloc(hir::Generics {
             params: self.arena.alloc_from_iter(params),
             predicates: self.arena.alloc_from_iter(predicates),
             has_where_clause_predicates,
             where_clause_span,
             span,
+            define_opaques,
         });
 
         (lowered_generics, res)
     }
 
+    pub(super) fn lower_define_opaques(
+        &mut self,
+        define_opaques: &Option<ThinVec<(NodeId, Path)>>,
+    ) -> Option<&'hir [LocalDefId]> {
+        define_opaques.as_ref().map(|d| {
+            &*self.arena.alloc_from_iter(
+                d.iter()
+                    // TODO: error reporting for non-local items being mentioned and tests that go through these code paths
+                    .map(|(id, _path)| {
+                        self.resolver
+                            .get_partial_res(*id)
+                            .unwrap()
+                            .expect_full_res()
+                            .def_id()
+                            .expect_local()
+                    }),
+            )
+        })
+    }
+
     pub(super) fn lower_generic_bound_predicate(
         &mut self,
         ident: Ident,