Rollup merge of rust-lang#161443 - khyperia:abbys-tests, r=BoxyUwU

add internal DSL for testing binders

implements rust-lang/project-assumptions-on-binders#8

apologies to the inevitable swarm of people who get pinged for this...

basically the only interesting diff is `compiler/rustc_hir_analysis/src/check/wfcheck.rs`, which actually implements the test. there's probably still features we want to add to this DSL (e.g. `RegionConstraint::AliasTyOutlivesViaEnv`), and there might be some bugs lurking, but this is at least a base to work off of. It's perma-unstable and for internal use only, so support and quality doesn't have to be incredibly high. For example, parser recovery and whatnot is just, bad, but whatever.

r? BoxyUwU

Author: JonathanBrouwer

compiler/rustc_ast/src/ast.rs

@@ -3733,29 +3733,7 @@ impl Item {
     }
 
     pub fn opt_generics(&self) -> Option<&Generics> {
-        match &self.kind {
-            ItemKind::ExternCrate(..)
-            | ItemKind::ConstBlock(_)
-            | ItemKind::Use(_)
-            | ItemKind::Mod(..)
-            | ItemKind::ForeignMod(_)
-            | ItemKind::GlobalAsm(_)
-            | ItemKind::MacCall(_)
-            | ItemKind::Delegation(_)
-            | ItemKind::DelegationMac(_)
-            | ItemKind::MacroDef(..) => None,
-            ItemKind::Static(_) => None,
-            ItemKind::Const(i) => Some(&i.generics),
-            ItemKind::Fn(i) => Some(&i.generics),
-            ItemKind::TyAlias(i) => Some(&i.generics),
-            ItemKind::TraitAlias(i) => Some(&i.generics),
-
-            ItemKind::Enum(_, generics, _)
-            | ItemKind::Struct(_, generics, _)
-            | ItemKind::Union(_, generics, _) => Some(&generics),
-            ItemKind::Trait(i) => Some(&i.generics),
-            ItemKind::Impl(i) => Some(&i.generics),
-        }
+        self.kind.generics()
     }
 }
 
@@ -4092,6 +4070,57 @@ impl Guard {
     }
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TestBinderConstraints {
+    pub generics: Generics,
+    pub body: Box<TestBinderBody>,
+}
+
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TestBinderBody {
+    pub foralls: ThinVec<TestBinderForall>,
+    pub exists: ThinVec<TestBinderExists>,
+    pub constraints: Vec<TestBinderConstraint>,
+}
+
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TestBinderForall {
+    pub span: Span,
+    pub node_id: NodeId,
+    pub generics: Generics,
+    pub body: TestBinderBody,
+    pub assert_on_exit: Option<ThinVec<TestBinderConstraint>>,
+}
+
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct TestBinderExists {
+    pub span: Span,
+    pub node_id: NodeId,
+    pub params: ThinVec<GenericParam>,
+    pub body: TestBinderBody,
+}
+
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum TestBinderConstraint {
+    And {
+        items: ThinVec<TestBinderConstraint>,
+    },
+    Or {
+        items: ThinVec<TestBinderConstraint>,
+    },
+    Lifetime {
+        #[visitable(extra = LifetimeCtxt::Bound)]
+        lhs: Lifetime,
+        #[visitable(extra = LifetimeCtxt::Bound)]
+        rhs: Lifetime,
+    },
+    Type {
+        lhs: Box<Ty>,
+        #[visitable(extra = LifetimeCtxt::Bound)]
+        rhs: Lifetime,
+    },
+}
+
 // Adding a new variant? Please update `test_item` in `tests/ui/macros/stringify.rs`.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ItemKind {
@@ -4173,6 +4202,8 @@ pub enum ItemKind {
     /// A list or glob delegation item (`reuse prefix::{a, b, c}`, `reuse prefix::*`).
     /// Treated similarly to a macro call and expanded early.
     DelegationMac(Box<DelegationMac>),
+    /// A `test_binder_constraints!()`. Perma-unstable, used only for rustc tests.
+    TestBinderConstraints(Box<TestBinderConstraints>),
 }
 
 impl ItemKind {
@@ -4199,17 +4230,31 @@ impl ItemKind {
             | ItemKind::GlobalAsm(_)
             | ItemKind::Impl(_)
             | ItemKind::MacCall(_)
-            | ItemKind::DelegationMac(_) => None,
+            | ItemKind::DelegationMac(_)
+            | ItemKind::TestBinderConstraints(_) => None,
         }
     }
 
     /// "a" or "an"
     pub fn article(&self) -> &'static str {
         use ItemKind::*;
         match self {
-            Use(..) | Static(..) | Const(..) | ConstBlock(..) | Fn(..) | Mod(..)
-            | GlobalAsm(..) | TyAlias(..) | Struct(..) | Union(..) | Trait(..) | TraitAlias(..)
-            | MacroDef(..) | Delegation(..) | DelegationMac(..) => "a",
+            Use(..)
+            | Static(..)
+            | Const(..)
+            | ConstBlock(..)
+            | Fn(..)
+            | Mod(..)
+            | GlobalAsm(..)
+            | TyAlias(..)
+            | Struct(..)
+            | Union(..)
+            | Trait(..)
+            | TraitAlias(..)
+            | MacroDef(..)
+            | Delegation(..)
+            | DelegationMac(..)
+            | TestBinderConstraints(..) => "a",
             ExternCrate(..) | ForeignMod(..) | MacCall(..) | Enum(..) | Impl { .. } => "an",
         }
     }
@@ -4236,6 +4281,7 @@ impl ItemKind {
             ItemKind::Impl { .. } => "implementation",
             ItemKind::Delegation(..) => "delegated function",
             ItemKind::DelegationMac(..) => "delegation",
+            ItemKind::TestBinderConstraints(..) => "test_binder_constraints!",
         }
     }
 
@@ -4249,7 +4295,8 @@ impl ItemKind {
             | Self::Union(_, generics, _)
             | Self::Trait(Trait { generics, .. })
             | Self::TraitAlias(TraitAlias { generics, .. })
-            | Self::Impl(Impl { generics, .. }) => Some(generics),
+            | Self::Impl(Impl { generics, .. })
+            | Self::TestBinderConstraints(TestBinderConstraints { generics, .. }) => Some(generics),
 
             Self::ExternCrate(..)
             | Self::Use(..)

compiler/rustc_ast/src/visit.rs

@@ -399,6 +399,9 @@ macro_rules! common_visitor_and_walkers {
             ThinVec<PathSegment>,
             ThinVec<PreciseCapturingArg>,
             ThinVec<Pat>,
+            ThinVec<TestBinderConstraint>,
+            ThinVec<TestBinderExists>,
+            ThinVec<TestBinderForall>,
             ThinVec<Box<Ty>>,
             ThinVec<TyPat>,
             ThinVec<EiiImpl>,
@@ -605,6 +608,11 @@ macro_rules! common_visitor_and_walkers {
                 fn visit_poly_trait_ref(PolyTraitRef);
                 fn visit_precise_capturing_arg(PreciseCapturingArg);
                 fn visit_qself(QSelf);
+                fn visit_test_binder_body(TestBinderBody);
+                fn visit_test_binder_constraint(TestBinderConstraint);
+                fn visit_test_binder_constraints(TestBinderConstraints);
+                fn visit_test_binder_exists(TestBinderExists);
+                fn visit_test_binder_forall(TestBinderForall);
                 fn visit_trait_ref(TraitRef);
                 fn visit_ty_pat(TyPat);
                 fn visit_ty(Ty);
@@ -870,6 +878,8 @@ macro_rules! common_visitor_and_walkers {
                         visit_visitable!($($mut)? vis, delegation),
                     ItemKind::DelegationMac(dm) =>
                         visit_visitable!($($mut)? vis, dm),
+                    ItemKind::TestBinderConstraints(item) =>
+                        visit_visitable!($($mut)? vis, item),
                 }
                 V::Result::output()
             }
@@ -1133,6 +1143,10 @@ macro_rules! common_visitor_and_walkers {
             pub fn walk_poly_trait_ref(PolyTraitRef);
             pub fn walk_precise_capturing_arg(PreciseCapturingArg);
             pub fn walk_qself(QSelf);
+            pub fn walk_test_binder_body(TestBinderBody);
+            pub fn walk_test_binder_constraint(TestBinderConstraint);
+            pub fn walk_test_binder_exists(TestBinderExists);
+            pub fn walk_test_binder_forall(TestBinderForall);
             pub fn walk_trait_ref(TraitRef);
             pub fn walk_ty_pat(TyPat);
             pub fn walk_ty(Ty);

compiler/rustc_ast_lowering/src/index.rs

@@ -431,4 +431,14 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         }
         intravisit::walk_precise_capturing_arg(self, arg);
     }
+
+    fn visit_test_binder_forall(&mut self, forall: &'hir TestBinderForall<'hir>) -> Self::Result {
+        self.insert(forall.span, forall.hir_id, Node::TestBinderForall(forall));
+        self.with_parent(forall.hir_id, |this| intravisit::walk_test_binder_forall(this, forall))
+    }
+
+    fn visit_test_binder_exists(&mut self, exists: &'hir TestBinderExists<'hir>) -> Self::Result {
+        self.insert(exists.span, exists.hir_id, Node::TestBinderExists(exists));
+        self.with_parent(exists.hir_id, |this| intravisit::walk_test_binder_exists(this, exists))
+    }
 }

compiler/rustc_ast_lowering/src/item.rs

@@ -200,7 +200,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             | ItemKind::MacCall(..)
             | ItemKind::MacroDef(..)
             | ItemKind::Delegation(..)
-            | ItemKind::DelegationMac(..) => Vec::new(),
+            | ItemKind::DelegationMac(..)
+            | ItemKind::TestBinderConstraints(..) => Vec::new(),
         }
     }
 
@@ -574,6 +575,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
             ItemKind::MacCall(..) | ItemKind::DelegationMac(..) => {
                 panic!("macros should have been expanded by now")
             }
+            ItemKind::TestBinderConstraints(TestBinderConstraints { generics, body }) => {
+                let (generics, body) = self.lower_generics(
+                    generics,
+                    ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    |this| this.lower_test_binder_body(body),
+                );
+                hir::ItemKind::TestBinderConstraints { generics, body: self.arena.alloc(body) }
+            }
         }
     }
 
@@ -2095,4 +2104,103 @@ impl<'hir> LoweringContext<'_, 'hir> {
         });
         hir::WherePredicate { hir_id, span, kind }
     }
+
+    fn lower_test_binder_body(&mut self, body: &TestBinderBody) -> hir::TestBinderBody<'hir> {
+        let foralls = self.arena.alloc_from_iter(
+            body.foralls.iter().map(|forall| self.lower_test_binder_forall(forall)),
+        );
+        let exists = self.arena.alloc_from_iter(
+            body.exists.iter().map(|exists| self.lower_test_binder_exists(exists)),
+        );
+        let constraints = self.lower_test_binder_constraints_as_and(&body.constraints);
+        hir::TestBinderBody { foralls, exists, constraints }
+    }
+
+    fn lower_test_binder_forall(
+        &mut self,
+        forall: &TestBinderForall,
+    ) -> hir::TestBinderForall<'hir> {
+        let (generics, body) = self.lower_generics(
+            &forall.generics,
+            ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+            |this| this.lower_test_binder_body(&forall.body),
+        );
+        let assert_on_exit = forall.assert_on_exit.as_ref().map(|assert_on_exit| {
+            self.arena.alloc(self.lower_test_binder_constraints_as_and(assert_on_exit)) as &_
+        });
+        hir::TestBinderForall {
+            span: self.lower_span(forall.span),
+            hir_id: self.lower_node_id(forall.node_id),
+            generics,
+            body: self.arena.alloc(body),
+            assert_on_exit,
+        }
+    }
+
+    fn lower_test_binder_exists(
+        &mut self,
+        exists: &TestBinderExists,
+    ) -> hir::TestBinderExists<'hir> {
+        let (generics, body) = self.lower_generics(
+            &Generics {
+                params: exists.params.clone(),
+                where_clause: Default::default(),
+                span: exists.span,
+            },
+            ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+            |this| this.lower_test_binder_body(&exists.body),
+        );
+        let params = generics.params;
+        hir::TestBinderExists {
+            span: self.lower_span(exists.span),
+            hir_id: self.lower_node_id(exists.node_id),
+            params,
+            body: self.arena.alloc(body),
+        }
+    }
+
+    // if there are multiple constraints in a block body, automatically wrap them in an `and {}`
+    fn lower_test_binder_constraints_as_and(
+        &mut self,
+        constraints: &[TestBinderConstraint],
+    ) -> hir::TestBinderConstraint<'hir> {
+        if constraints.len() == 1 {
+            self.lower_test_binder_constraint(&constraints[0])
+        } else {
+            hir::TestBinderConstraint::And {
+                items: self.arena.alloc_from_iter(
+                    constraints.iter().map(|item| self.lower_test_binder_constraint(item)),
+                ),
+            }
+        }
+    }
+
+    fn lower_test_binder_constraint(
+        &mut self,
+        constraint: &TestBinderConstraint,
+    ) -> hir::TestBinderConstraint<'hir> {
+        match constraint {
+            TestBinderConstraint::And { items } => hir::TestBinderConstraint::And {
+                items: self.arena.alloc_from_iter(
+                    items.iter().map(|item| self.lower_test_binder_constraint(item)),
+                ),
+            },
+            TestBinderConstraint::Or { items } => hir::TestBinderConstraint::Or {
+                items: self.arena.alloc_from_iter(
+                    items.iter().map(|item| self.lower_test_binder_constraint(item)),
+                ),
+            },
+            TestBinderConstraint::Lifetime { lhs, rhs } => {
+                let lhs = self.lower_lifetime(lhs, LifetimeSource::Other, lhs.ident.into());
+                let rhs = self.lower_lifetime(rhs, LifetimeSource::OutlivesBound, rhs.ident.into());
+                hir::TestBinderConstraint::Lifetime { lhs, rhs }
+            }
+            TestBinderConstraint::Type { lhs, rhs } => {
+                let lhs = self
+                    .lower_ty_alloc(lhs, ImplTraitContext::Disallowed(ImplTraitPosition::Bound));
+                let rhs = self.lower_lifetime(rhs, LifetimeSource::OutlivesBound, rhs.ident.into());
+                hir::TestBinderConstraint::Type { lhs, rhs }
+            }
+        }
+    }
 }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -413,6 +413,16 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         }
         visit::walk_assoc_item(self, i, ctxt)
     }
+
+    fn visit_test_binder_forall(&mut self, forall: &'a ast::TestBinderForall) {
+        self.check_late_bound_lifetime_defs(&forall.generics.params);
+        visit::walk_test_binder_forall(self, forall)
+    }
+
+    fn visit_test_binder_exists(&mut self, exists: &'a ast::TestBinderExists) {
+        self.check_late_bound_lifetime_defs(&exists.params);
+        visit::walk_test_binder_exists(self, exists)
+    }
 }
 
 // -----------------------------------------------------------------------------

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -450,6 +450,9 @@ impl<'a> State<'a> {
                 },
                 &deleg.body,
             ),
+            ast::ItemKind::TestBinderConstraints(_) => {
+                self.word("test_binder_constraints!(/* pretty-printing not supported */)")
+            }
         }
         self.ann.post(self, AnnNode::Item(item))
     }

compiler/rustc_attr_ir/src/target.rs

@@ -143,6 +143,7 @@ impl Target {
             ast::ItemKind::MacroDef(..) => Target::MacroDef,
             ast::ItemKind::Delegation(..) => Target::Delegation { mac: false },
             ast::ItemKind::DelegationMac(..) => Target::Delegation { mac: true },
+            ast::ItemKind::TestBinderConstraints(..) => Target::MacroCall,
         }
     }
 

compiler/rustc_builtin_macros/src/lib.rs

@@ -47,6 +47,7 @@ mod offload;
 mod pattern_type;
 mod source_util;
 mod test;
+mod test_binder_constraints;
 mod trace_macros;
 mod view_type;
 
@@ -100,6 +101,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         pattern_type: pattern_type::expand,
         std_panic: edition_panic::expand_panic,
         stringify: source_util::expand_stringify,
+        test_binder_constraints: test_binder_constraints::expand,
         trace_macros: trace_macros::expand_trace_macros,
         unreachable: edition_panic::expand_unreachable,
         view_type: view_type::expand,