Rollup merge of rust-lang#124637 - fmease:ast-pretty-ty-asc-builtin-s…

…yn, r=compiler-errors

AST pretty: Use `builtin_syntax` for type ascription

Follow-up to rust-lang#122806.
CC #124619.

compiler/rustc_ast/src/ast.rs

@@ -1390,7 +1390,7 @@ pub struct StructExpr {
 // Adding a new variant? Please update `test_expr` in `tests/ui/macros/stringify.rs`.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ExprKind {
- /// An array (`[a, b, c, d]`)
+ /// An array (e.g, `[a, b, c, d]`).
  Array(ThinVec<P<Expr>>),
  /// Allow anonymous constants from an inline `const` block
  ConstBlock(AnonConst),
@@ -1401,7 +1401,7 @@ pub enum ExprKind {
  /// This also represents calling the constructor of
  /// tuple-like ADTs such as tuple structs and enum variants.
  Call(P<Expr>, ThinVec<P<Expr>>),
- /// A method call (e.g. `x.foo::<Bar, Baz>(a, b, c)`).
+ /// A method call (e.g., `x.foo::<Bar, Baz>(a, b, c)`).
  MethodCall(Box<MethodCall>),
  /// A tuple (e.g., `(a, b, c, d)`).
  Tup(ThinVec<P<Expr>>),
@@ -1413,7 +1413,10 @@ pub enum ExprKind {
  Lit(token::Lit),
  /// A cast (e.g., `foo as f64`).
  Cast(P<Expr>, P<Ty>),
- /// A type ascription (e.g., `42: usize`).
+ /// A type ascription (e.g., `builtin # type_ascribe(42, usize)`).
+ ///
+ /// Usually not written directly in user code but
+ /// indirectly via the macro `type_ascribe!(...)`.
  Type(P<Expr>, P<Ty>),
  /// A `let pat = expr` expression that is only semantically allowed in the condition
  /// of `if` / `while` expressions. (e.g., `if let 0 = x { .. }`).
@@ -1488,7 +1491,10 @@ pub enum ExprKind {
  /// Output of the `asm!()` macro.
  InlineAsm(P<InlineAsm>),
 
- /// Output of the `offset_of!()` macro.
+ /// An `offset_of` expression (e.g., `builtin # offset_of(Struct, field)`).
+ ///
+ /// Usually not written directly in user code but
+ /// indirectly via the macro `core::mem::offset_of!(...)`.
  OffsetOf(P<Ty>, P<[Ident]>),
 
  /// A macro invocation; pre-expansion.

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

@@ -422,7 +422,8 @@ impl<'a> State<'a> {
  self.print_type(ty);
  }
  ast::ExprKind::Type(expr, ty) => {
- self.word("type_ascribe!(");
+ self.word("builtin # type_ascribe");
+ self.popen();
  self.ibox(0);
  self.print_expr(expr, FixupContext::default());
 
@@ -431,7 +432,7 @@ impl<'a> State<'a> {
  self.print_type(ty);
 
  self.end();
- self.word(")");
+ self.pclose();
  }
  ast::ExprKind::Let(pat, scrutinee, _, _) => {
  self.print_let(pat, scrutinee, fixup);
@@ -657,15 +658,15 @@ impl<'a> State<'a> {
  );
  }
  ast::ExprKind::InlineAsm(a) => {
- // FIXME: This should have its own syntax, distinct from a macro invocation.
+ // FIXME: Print `builtin # asm` once macro `asm` uses `builtin_syntax`.
  self.word("asm!");
  self.print_inline_asm(a);
  }
  ast::ExprKind::FormatArgs(fmt) => {
- // FIXME: This should have its own syntax, distinct from a macro invocation.
+ // FIXME: Print `builtin # format_args` once macro `format_args` uses `builtin_syntax`.
  self.word("format_args!");
  self.popen();
- self.rbox(0, Inconsistent);
+ self.ibox(0);
  self.word(reconstruct_format_args_template_string(&fmt.template));
  for arg in fmt.arguments.all_args() {
  self.word_space(",");
@@ -677,7 +678,7 @@ impl<'a> State<'a> {
  ast::ExprKind::OffsetOf(container, fields) => {
  self.word("builtin # offset_of");
  self.popen();
- self.rbox(0, Inconsistent);
+ self.ibox(0);
  self.print_type(container);
  self.word(",");
  self.space();
@@ -690,8 +691,8 @@ impl<'a> State<'a> {
  self.print_ident(field);
  }
  }
- self.pclose();
  self.end();
+ self.pclose();
  }
  ast::ExprKind::MacCall(m) => self.print_mac(m),
  ast::ExprKind::Paren(e) => {

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

@@ -238,6 +238,7 @@ impl<'a> State<'a> {
  self.bclose(item.span, empty);
  }
  ast::ItemKind::GlobalAsm(asm) => {
+ // FIXME: Print `builtin # global_asm` once macro `global_asm` uses `builtin_syntax`.
  self.head(visibility_qualified(&item.vis, "global_asm!"));
  self.print_inline_asm(asm);
  self.word(";");