Auto merge of rust-lang#124645 - fmease:rollup-cp1aaaj, r=fmease

Rollup of 7 pull requests

Successful merges:

 - rust-lang#124441 (String.truncate comment microfix (greater or equal))
 - rust-lang#124594 (run-make-support: preserve tooks.mk behavior for EXTRACXXFLAGS)
 - rust-lang#124604 (library/std: Remove unused `gimli-symbolize` feature)
 - rust-lang#124607 (`rustc_expand` cleanups)
 - rust-lang#124609 (variable-precision float operations can differ depending on optimization levels)
 - rust-lang#124610 (Tweak `consts_may_unify`)
 - rust-lang#124637 (AST pretty: Use `builtin_syntax` for type ascription)

Failed merges:

 - rust-lang#124638 (Move some tests from `rustc_expand` to `rustc_parse`.)

r? `@ghost`
`@rustbot` modify labels: rollup

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(";");

compiler/rustc_expand/src/base.rs

@@ -21,7 +21,7 @@ use rustc_session::config::CollapseMacroDebuginfo;
 use rustc_session::{parse::ParseSess, Limit, Session};
 use rustc_span::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_span::edition::Edition;
-use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId};
+use rustc_span::hygiene::{AstPass, ExpnData, ExpnKind, LocalExpnId, MacroKind};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{FileName, Span, DUMMY_SP};
@@ -32,8 +32,6 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use thin_vec::ThinVec;
 
-pub(crate) use rustc_span::hygiene::MacroKind;
-
 // When adding new variants, make sure to
 // adjust the `visit_*` / `flat_map_*` calls in `InvocationCollector`
 // to use `assign_id!`
@@ -573,35 +571,6 @@ impl DummyResult {
  tokens: None,
  })
  }
-
- /// A plain dummy pattern.
- pub fn raw_pat(sp: Span) -> ast::Pat {
- ast::Pat { id: ast::DUMMY_NODE_ID, kind: PatKind::Wild, span: sp, tokens: None }
- }
-
- /// A plain dummy type.
- pub fn raw_ty(sp: Span) -> P<ast::Ty> {
- // FIXME(nnethercote): you might expect `ast::TyKind::Dummy` to be used here, but some
- // values produced here end up being lowered to HIR, which `ast::TyKind::Dummy` does not
- // support, so we use an empty tuple instead.
- P(ast::Ty {
- id: ast::DUMMY_NODE_ID,
- kind: ast::TyKind::Tup(ThinVec::new()),
- span: sp,
- tokens: None,
- })
- }
-
- /// A plain dummy crate.
- pub fn raw_crate() -> ast::Crate {
- ast::Crate {
- attrs: Default::default(),
- items: Default::default(),
- spans: Default::default(),
- id: ast::DUMMY_NODE_ID,
- is_placeholder: Default::default(),
- }
- }
 }
 
 impl MacResult for DummyResult {
@@ -610,7 +579,12 @@ impl MacResult for DummyResult {
  }
 
  fn make_pat(self: Box<DummyResult>) -> Option<P<ast::Pat>> {
- Some(P(DummyResult::raw_pat(self.span)))
+ Some(P(ast::Pat {
+ id: ast::DUMMY_NODE_ID,
+ kind: PatKind::Wild,
+ span: self.span,
+ tokens: None,
+ }))
  }
 
  fn make_items(self: Box<DummyResult>) -> Option<SmallVec<[P<ast::Item>; 1]>> {
@@ -638,7 +612,15 @@ impl MacResult for DummyResult {
  }
 
  fn make_ty(self: Box<DummyResult>) -> Option<P<ast::Ty>> {
- Some(DummyResult::raw_ty(self.span))
+ // FIXME(nnethercote): you might expect `ast::TyKind::Dummy` to be used here, but some
+ // values produced here end up being lowered to HIR, which `ast::TyKind::Dummy` does not
+ // support, so we use an empty tuple instead.
+ Some(P(ast::Ty {
+ id: ast::DUMMY_NODE_ID,
+ kind: ast::TyKind::Tup(ThinVec::new()),
+ span: self.span,
+ tokens: None,
+ }))
  }
 
  fn make_arms(self: Box<DummyResult>) -> Option<SmallVec<[ast::Arm; 1]>> {
@@ -670,7 +652,13 @@ impl MacResult for DummyResult {
  }
 
  fn make_crate(self: Box<DummyResult>) -> Option<ast::Crate> {
- Some(DummyResult::raw_crate())
+ Some(ast::Crate {
+ attrs: Default::default(),
+ items: Default::default(),
+ spans: Default::default(),
+ id: ast::DUMMY_NODE_ID,
+ is_placeholder: Default::default(),
+ })
  }
 }
 

compiler/rustc_expand/src/build.rs

@@ -175,20 +175,6 @@ impl<'a> ExtCtxt<'a> {
  ast::Stmt { id: ast::DUMMY_NODE_ID, span: expr.span, kind: ast::StmtKind::Expr(expr) }
  }
 
- pub fn stmt_let_pat(&self, sp: Span, pat: P<ast::Pat>, ex: P<ast::Expr>) -> ast::Stmt {
- let local = P(ast::Local {
- pat,
- ty: None,
- id: ast::DUMMY_NODE_ID,
- kind: LocalKind::Init(ex),
- span: sp,
- colon_sp: None,
- attrs: AttrVec::new(),
- tokens: None,
- });
- self.stmt_local(local, sp)
- }
-
  pub fn stmt_let(&self, sp: Span, mutbl: bool, ident: Ident, ex: P<ast::Expr>) -> ast::Stmt {
  self.stmt_let_ty(sp, mutbl, ident, None, ex)
  }
@@ -278,10 +264,6 @@ impl<'a> ExtCtxt<'a> {
  self.expr_ident(span, Ident::with_dummy_span(kw::SelfLower))
  }
 
- pub fn expr_field(&self, span: Span, expr: P<Expr>, field: Ident) -> P<ast::Expr> {
- self.expr(span, ast::ExprKind::Field(expr, field))
- }
-
  pub fn expr_macro_call(&self, span: Span, call: P<ast::MacCall>) -> P<ast::Expr> {
  self.expr(span, ast::ExprKind::MacCall(call))
  }
@@ -394,11 +376,6 @@ impl<'a> ExtCtxt<'a> {
  self.expr(span, ast::ExprKind::Lit(lit))
  }
 
- pub fn expr_char(&self, span: Span, ch: char) -> P<ast::Expr> {
- let lit = token::Lit::new(token::Char, literal::escape_char_symbol(ch), None);
- self.expr(span, ast::ExprKind::Lit(lit))
- }
-
  pub fn expr_byte_str(&self, span: Span, bytes: Vec<u8>) -> P<ast::Expr> {
  let lit = token::Lit::new(token::ByteStr, literal::escape_byte_str_symbol(&bytes), None);
  self.expr(span, ast::ExprKind::Lit(lit))
@@ -414,10 +391,6 @@ impl<'a> ExtCtxt<'a> {
  self.expr_addr_of(sp, self.expr_array(sp, exprs))
  }
 
- pub fn expr_cast(&self, sp: Span, expr: P<ast::Expr>, ty: P<ast::Ty>) -> P<ast::Expr> {
- self.expr(sp, ast::ExprKind::Cast(expr, ty))
- }
-
  pub fn expr_some(&self, sp: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
  let some = self.std_path(&[sym::option, sym::Option, sym::Some]);
  self.expr_call_global(sp, some, thin_vec![expr])

compiler/rustc_expand/src/config.rs

@@ -99,10 +99,11 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
  // If the declared feature is unstable, record it.
  if let Some(f) = UNSTABLE_FEATURES.iter().find(|f| name == f.feature.name) {
  (f.set_enabled)(&mut features);
- // When the ICE comes from core, alloc or std (approximation of the standard library), there's a chance
- // that the person hitting the ICE may be using -Zbuild-std or similar with an untested target.
- // The bug is probably in the standard library and not the compiler in that case, but that doesn't
- // really matter - we want a bug report.
+ // When the ICE comes from core, alloc or std (approximation of the standard
+ // library), there's a chance that the person hitting the ICE may be using
+ // -Zbuild-std or similar with an untested target. The bug is probably in the
+ // standard library and not the compiler in that case, but that doesn't really
+ // matter - we want a bug report.
  if features.internal(name)
  && ![sym::core, sym::alloc, sym::std].contains(&crate_name)
  {