Auto merge of #117050 - c410-f3r:here-we-go-again, r=petrochenkov

[`RFC 3086`] Attempt to try to resolve blocking concerns
Implements what is described at #83527 (comment) to hopefully make some progress.
It is unknown if such approach is or isn't desired due to the lack of further feedback, as such, it is probably best to nominate this PR to the official entities.
`@rustbot` labels +I-compiler-nominated

Author: bors

compiler/rustc_data_structures/src/tagged_ptr/impl_tag.rs

@@ -81,6 +81,7 @@
 /// E::A,
 /// }
 /// ```
+#[cfg(bootstrap)]
 #[macro_export]
 macro_rules! impl_tag {
 (
@@ -140,5 +141,148 @@ macro_rules! impl_tag {
 };
 }
 
+/// Implements [`Tag`] for a given type.
+///
+/// You can use `impl_tag` on structs and enums.
+/// You need to specify the type and all its possible values,
+/// which can only be paths with optional fields.
+///
+/// [`Tag`]: crate::tagged_ptr::Tag
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(macro_metavar_expr)]
+/// use rustc_data_structures::{impl_tag, tagged_ptr::Tag};
+///
+/// #[derive(Copy, Clone, PartialEq, Debug)]
+/// enum SomeTag {
+/// A,
+/// B,
+/// X { v: bool },
+/// Y(bool, bool),
+/// }
+///
+/// impl_tag! {
+/// // The type for which the `Tag` will be implemented
+/// impl Tag for SomeTag;
+/// // You need to specify all possible tag values:
+/// SomeTag::A, // 0
+/// SomeTag::B, // 1
+/// // For variants with fields, you need to specify the fields:
+/// SomeTag::X { v: true }, // 2
+/// SomeTag::X { v: false }, // 3
+/// // For tuple variants use named syntax:
+/// SomeTag::Y { 0: true, 1: true }, // 4
+/// SomeTag::Y { 0: false, 1: true }, // 5
+/// SomeTag::Y { 0: true, 1: false }, // 6
+/// SomeTag::Y { 0: false, 1: false }, // 7
+/// }
+///
+/// // Tag values are assigned in order:
+/// assert_eq!(SomeTag::A.into_usize(), 0);
+/// assert_eq!(SomeTag::X { v: false }.into_usize(), 3);
+/// assert_eq!(SomeTag::Y(false, true).into_usize(), 5);
+///
+/// assert_eq!(unsafe { SomeTag::from_usize(1) }, SomeTag::B);
+/// assert_eq!(unsafe { SomeTag::from_usize(2) }, SomeTag::X { v: true });
+/// assert_eq!(unsafe { SomeTag::from_usize(7) }, SomeTag::Y(false, false));
+/// ```
+///
+/// Structs are supported:
+///
+/// ```
+/// #![feature(macro_metavar_expr)]
+/// # use rustc_data_structures::impl_tag;
+/// #[derive(Copy, Clone)]
+/// struct Flags { a: bool, b: bool }
+///
+/// impl_tag! {
+/// impl Tag for Flags;
+/// Flags { a: true, b: true },
+/// Flags { a: false, b: true },
+/// Flags { a: true, b: false },
+/// Flags { a: false, b: false },
+/// }
+/// ```
+///
+/// Not specifying all values results in a compile error:
+///
+/// ```compile_fail,E0004
+/// #![feature(macro_metavar_expr)]
+/// # use rustc_data_structures::impl_tag;
+/// #[derive(Copy, Clone)]
+/// enum E {
+/// A,
+/// B,
+/// }
+///
+/// impl_tag! {
+/// impl Tag for E;
+/// E::A,
+/// }
+/// ```
+#[cfg(not(bootstrap))]
+#[macro_export]
+macro_rules! impl_tag {
+(
+implTagfor $Self:ty;
+ $(
+ $($path:ident)::* $({ $( $fields:tt )*})?,
+)*
+) => {
+// Safety:
+// `bits_for_tags` is called on the same `${index()}`-es as
+// `into_usize` returns, thus `BITS` constant is correct.
+unsafeimpl $crate::tagged_ptr::Tagfor $Self {
+constBITS:u32 = $crate::tagged_ptr::bits_for_tags(&[
+ $(
+ ${index()},
+ $( ${ignore($path)})*
+)*
+]);
+
+ #[inline]
+fn into_usize(self) -> usize{
+// This forbids use of repeating patterns (`Enum::V`&`Enum::V`, etc)
+// (or at least it should, see <https://github.com/rust-lang/rust/issues/110613>)
+ #[forbid(unreachable_patterns)]
+matchself{
+// `match` is doing heavy lifting here, by requiring exhaustiveness
+ $(
+ $($path)::* $({ $( $fields )*})? => ${index()},
+)*
+}
+}
+
+ #[inline]
+unsafefn from_usize(tag:usize) -> Self{
+match tag {
+ $(
+ ${index()} => $($path)::* $({ $( $fields )*})?,
+)*
+
+// Safety:
+// `into_usize` only returns `${index()}` of the same
+// repetition as we are filtering above, thus if this is
+// reached, the safety contract of this function was
+// already breached.
+ _ => unsafe{
+ debug_assert!(
+false,
+"invalid tag: {tag}\
+ (this is a bug in the caller of `from_usize`)"
+);
+ std::hint::unreachable_unchecked()
+},
+}
+}
+
+}
+};
+}
+
 #[cfg(test)]
 mod tests;

compiler/rustc_expand/src/expand.rs

@@ -41,6 +41,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::{iter, mem};
 
+#[cfg(bootstrap)]
 macro_rules! ast_fragments {
 (
  $($Kind:ident($AstTy:ty){
@@ -165,6 +166,131 @@ macro_rules! ast_fragments {
 }
 }
 
+#[cfg(not(bootstrap))]
+macro_rules! ast_fragments {
+(
+ $($Kind:ident($AstTy:ty){
+ $kind_name:expr;
+ $(one fn $mut_visit_ast:ident;fn $visit_ast:ident;)?
+ $(many fn $flat_map_ast_elt:ident;fn $visit_ast_elt:ident($($args:tt)*);)?
+fn $make_ast:ident;
+})*
+) => {
+/// A fragment of AST that can be produced by a single macro expansion.
+/// Can also serve as an input and intermediate result for macro expansion operations.
+pubenumAstFragment{
+OptExpr(Option<P<ast::Expr>>),
+MethodReceiverExpr(P<ast::Expr>),
+ $($Kind($AstTy),)*
+}
+
+/// "Discriminant" of an AST fragment.
+ #[derive(Copy,Clone,PartialEq,Eq)]
+pubenumAstFragmentKind{
+OptExpr,
+MethodReceiverExpr,
+ $($Kind,)*
+}
+
+implAstFragmentKind{
+pubfn name(self) -> &'staticstr{
+matchself{
+AstFragmentKind::OptExpr => "expression",
+AstFragmentKind::MethodReceiverExpr => "expression",
+ $(AstFragmentKind::$Kind => $kind_name,)*
+}
+}
+
+fn make_from<'a>(self, result:Box<dyn MacResult + 'a>) -> Option<AstFragment> {
+matchself{
+AstFragmentKind::OptExpr =>
+ result.make_expr().map(Some).map(AstFragment::OptExpr),
+AstFragmentKind::MethodReceiverExpr =>
+ result.make_expr().map(AstFragment::MethodReceiverExpr),
+ $(AstFragmentKind::$Kind => result.$make_ast().map(AstFragment::$Kind),)*
+}
+}
+}
+
+implAstFragment{
+pubfn add_placeholders(&mutself, placeholders:&[NodeId]){
+if placeholders.is_empty(){
+return;
+}
+matchself{
+ $($(AstFragment::$Kind(ast) => ast.extend(placeholders.iter().flat_map(|id| {
+ ${ignore($flat_map_ast_elt)}
+ placeholder(AstFragmentKind::$Kind,*id,None).$make_ast()
+})),)?)*
+ _ => panic!("unexpected AST fragment kind")
+}
+}
+
+pubfn make_opt_expr(self) -> Option<P<ast::Expr>> {
+matchself{
+AstFragment::OptExpr(expr) => expr,
+ _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
+}
+}
+
+pubfn make_method_receiver_expr(self) -> P<ast::Expr> {
+matchself{
+AstFragment::MethodReceiverExpr(expr) => expr,
+ _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
+}
+}
+
+ $(pubfn $make_ast(self) -> $AstTy {
+matchself{
+AstFragment::$Kind(ast) => ast,
+ _ => panic!("AstFragment::make_* called on the wrong kind of fragment"),
+}
+})*
+
+fn make_ast<T:InvocationCollectorNode>(self) -> T::OutputTy{
+T::fragment_to_output(self)
+}
+
+pubfn mut_visit_with<F:MutVisitor>(&mutself, vis:&mutF){
+matchself{
+AstFragment::OptExpr(opt_expr) => {
+ visit_clobber(opt_expr, |opt_expr| {
+ifletSome(expr) = opt_expr {
+ vis.filter_map_expr(expr)
+} else {
+None
+}
+});
+}
+AstFragment::MethodReceiverExpr(expr) => vis.visit_method_receiver_expr(expr),
+ $($(AstFragment::$Kind(ast) => vis.$mut_visit_ast(ast),)?)*
+ $($(AstFragment::$Kind(ast) =>
+ ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast)),)?)*
+}
+}
+
+pubfn visit_with<'a,V:Visitor<'a>>(&'a self, visitor:&mutV){
+matchself{
+AstFragment::OptExpr(Some(expr)) => visitor.visit_expr(expr),
+AstFragment::OptExpr(None) => {}
+AstFragment::MethodReceiverExpr(expr) => visitor.visit_method_receiver_expr(expr),
+ $($(AstFragment::$Kind(ast) => visitor.$visit_ast(ast),)?)*
+ $($(AstFragment::$Kind(ast) => for ast_elt in &ast[..]{
+ visitor.$visit_ast_elt(ast_elt, $($args)*);
+})?)*
+}
+}
+}
+
+impl<'a> MacResultforcrate::mbe::macro_rules::ParserAnyMacro<'a> {
+ $(fn $make_ast(self:Box<crate::mbe::macro_rules::ParserAnyMacro<'a>>)
+ -> Option<$AstTy> {
+Some(self.make(AstFragmentKind::$Kind).$make_ast())
+})*
+}
+}
+}
+
 ast_fragments!{
 Expr(P<ast::Expr>){"expression"; one fn visit_expr;fn visit_expr;fn make_expr;}
 Pat(P<ast::Pat>){"pattern"; one fn visit_pat;fn visit_pat;fn make_pat;}

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -10,9 +10,8 @@ use rustc_span::Span;
 /// A meta-variable expression, for expansions based on properties of meta-variables.
 #[derive(Debug,Clone,PartialEq,Encodable,Decodable)]
 pub(crate)enumMetaVarExpr{
-/// The number of repetitions of an identifier, optionally limited to a number
-/// of outer-most repetition depths. If the depth limit is `None` then the depth is unlimited.
-Count(Ident,Option<usize>),
+/// The number of repetitions of an identifier.
+Count(Ident,usize),
 
 /// Ignore a meta-variable for repetition without expansion.
 Ignore(Ident),
@@ -43,7 +42,10 @@ impl MetaVarExpr {
 letmut iter = args.trees();
 let rslt = match ident.as_str(){
 "count" => parse_count(&mut iter, sess, ident.span)?,
-"ignore" => MetaVarExpr::Ignore(parse_ident(&mut iter, sess, ident.span)?),
+"ignore" => {
+eat_dollar(&mut iter, sess, ident.span)?;
+MetaVarExpr::Ignore(parse_ident(&mut iter, sess, ident.span)?)
+}
 "index" => MetaVarExpr::Index(parse_depth(&mut iter, sess, ident.span)?),
 "length" => MetaVarExpr::Length(parse_depth(&mut iter, sess, ident.span)?),
  _ => {
@@ -92,6 +94,7 @@ fn parse_count<'sess>(
 sess:&'sessParseSess,
 span:Span,
 ) -> PResult<'sess,MetaVarExpr>{
+eat_dollar(iter, sess, span)?;
 let ident = parse_ident(iter, sess, span)?;
 let depth = iftry_eat_comma(iter){
 if iter.look_ahead(0).is_none(){
@@ -100,9 +103,9 @@ fn parse_count<'sess>(
 "`count` followed by a comma must have an associated index indicating its depth",
 ));
 }
-Some(parse_depth(iter, sess, span)?)
+parse_depth(iter, sess, span)?
 }else{
-None
+0
 };
 Ok(MetaVarExpr::Count(ident, depth))
 }
@@ -166,3 +169,20 @@ fn try_eat_comma(iter: &mut RefTokenTreeCursor<'_>) -> bool {
 }
 false
 }
+
+/// Expects that the next item is a dollar sign.
+fneat_dollar<'sess>(
+iter:&mutRefTokenTreeCursor<'_>,
+sess:&'sessParseSess,
+span:Span,
+) -> PResult<'sess,()>{
+ifletSome(TokenTree::Token(token::Token{kind: token::Dollar, .. }, _)) = iter.look_ahead(0)
+{
+let _ = iter.next();
+returnOk(());
+}
+Err(sess.span_diagnostic.struct_span_err(
+ span,
+"meta-variables within meta-variable expressions must be referenced using a dollar sign",
+))
+}