Auto merge of #127476 - jieyouxu:rollup-16wyb0b, r=jieyouxu

Rollup of 10 pull requests

Successful merges:

 - #126841 ([`macro_metavar_expr_concat`] Add support for literals)
 - #126881 (Make `NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE` a deny-by-default lint in edition 2024)
 - #126921 (Give VaList its own home)
 - #127367 (Run alloc sync tests)
 - #127431 (Use field ident spans directly instead of the full field span in diagnostics on local fields)
 - #127437 (Uplift trait ref is knowable into `rustc_next_trait_solver`)
 - #127439 (Uplift elaboration into `rustc_type_ir`)
 - #127451 (Improve `run-make/output-type-permutations` code and improve `filename_not_in_denylist` API)
 - #127452 (Fix intrinsic const parameter counting with `effects`)
 - #127459 (rustdoc-json: add type/trait alias tests)

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

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -1,14 +1,15 @@
-use rustc_ast::token::{self, Delimiter, IdentIsRaw};
+use rustc_ast::token::{self, Delimiter, IdentIsRaw, Lit, Token, TokenKind};
 use rustc_ast::tokenstream::{RefTokenTreeCursor, TokenStream, TokenTree};
 use rustc_ast::{LitIntType, LitKind};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, PResult};
 use rustc_macros::{Decodable, Encodable};
 use rustc_session::parse::ParseSess;
 use rustc_span::symbol::Ident;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 pub(crate) const RAW_IDENT_ERR: &str = "`${concat(..)}` currently does not support raw identifiers";
+pub(crate) const UNSUPPORTED_CONCAT_ELEM_ERR: &str = "expected identifier or string literal";
 
 /// A meta-variable expression, for expansions based on properties of meta-variables.
 #[derive(Debug, PartialEq, Encodable, Decodable)]
@@ -51,11 +52,26 @@ impl MetaVarExpr {
  let mut result = Vec::new();
  loop {
  let is_var = try_eat_dollar(&mut iter);
- let element_ident = parse_ident(&mut iter, psess, outer_span)?;
+ let token = parse_token(&mut iter, psess, outer_span)?;
  let element = if is_var {
- MetaVarExprConcatElem::Var(element_ident)
+ MetaVarExprConcatElem::Var(parse_ident_from_token(psess, token)?)
+ } else if let TokenKind::Literal(Lit {
+ kind: token::LitKind::Str,
+ symbol,
+ suffix: None,
+ }) = token.kind
+ {
+ MetaVarExprConcatElem::Literal(symbol)
  } else {
- MetaVarExprConcatElem::Ident(element_ident)
+ match parse_ident_from_token(psess, token) {
+ Err(err) => {
+ err.cancel();
+ return Err(psess
+ .dcx()
+ .struct_span_err(token.span, UNSUPPORTED_CONCAT_ELEM_ERR));
+ }
+ Ok(elem) => MetaVarExprConcatElem::Ident(elem),
+ }
  };
  result.push(element);
  if iter.look_ahead(0).is_none() {
@@ -105,11 +121,13 @@ impl MetaVarExpr {
 
 #[derive(Debug, Decodable, Encodable, PartialEq)]
 pub(crate) enum MetaVarExprConcatElem {
- /// There is NO preceding dollar sign, which means that this identifier should be interpreted
- /// as a literal.
+ /// Identifier WITHOUT a preceding dollar sign, which means that this identifier should be
+ /// interpreted as a literal.
  Ident(Ident),
- /// There is a preceding dollar sign, which means that this identifier should be expanded
- /// and interpreted as a variable.
+ /// For example, a number or a string.
+ Literal(Symbol),
+ /// Identifier WITH a preceding dollar sign, which means that this identifier should be
+ /// expanded and interpreted as a variable.
  Var(Ident),
 }
 
@@ -158,7 +176,7 @@ fn parse_depth<'psess>(
  span: Span,
 ) -> PResult<'psess, usize> {
  let Some(tt) = iter.next() else { return Ok(0) };
- let TokenTree::Token(token::Token { kind: token::TokenKind::Literal(lit), .. }, _) = tt else {
+ let TokenTree::Token(Token { kind: TokenKind::Literal(lit), .. }, _) = tt else {
  return Err(psess
  .dcx()
  .struct_span_err(span, "meta-variable expression depth must be a literal"));
@@ -180,12 +198,14 @@ fn parse_ident<'psess>(
  psess: &'psess ParseSess,
  fallback_span: Span,
 ) -> PResult<'psess, Ident> {
- let Some(tt) = iter.next() else {
- return Err(psess.dcx().struct_span_err(fallback_span, "expected identifier"));
- };
- let TokenTree::Token(token, _) = tt else {
- return Err(psess.dcx().struct_span_err(tt.span(), "expected identifier"));
- };
+ let token = parse_token(iter, psess, fallback_span)?;
+ parse_ident_from_token(psess, token)
+}
+
+fn parse_ident_from_token<'psess>(
+ psess: &'psess ParseSess,
+ token: &Token,
+) -> PResult<'psess, Ident> {
  if let Some((elem, is_raw)) = token.ident() {
  if let IdentIsRaw::Yes = is_raw {
  return Err(psess.dcx().struct_span_err(elem.span, RAW_IDENT_ERR));
@@ -205,10 +225,24 @@ fn parse_ident<'psess>(
  Err(err)
 }
 
+fn parse_token<'psess, 't>(
+ iter: &mut RefTokenTreeCursor<'t>,
+ psess: &'psess ParseSess,
+ fallback_span: Span,
+) -> PResult<'psess, &'t Token> {
+ let Some(tt) = iter.next() else {
+ return Err(psess.dcx().struct_span_err(fallback_span, UNSUPPORTED_CONCAT_ELEM_ERR));
+ };
+ let TokenTree::Token(token, _) = tt else {
+ return Err(psess.dcx().struct_span_err(tt.span(), UNSUPPORTED_CONCAT_ELEM_ERR));
+ };
+ Ok(token)
+}
+
 /// Tries to move the iterator forward returning `true` if there is a comma. If not, then the
 /// iterator is not modified and the result is `false`.
 fn try_eat_comma(iter: &mut RefTokenTreeCursor<'_>) -> bool {
- if let Some(TokenTree::Token(token::Token { kind: token::Comma, .. }, _)) = iter.look_ahead(0) {
+ if let Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) = iter.look_ahead(0) {
  let _ = iter.next();
  return true;
  }
@@ -218,8 +252,7 @@ fn try_eat_comma(iter: &mut RefTokenTreeCursor<'_>) -> bool {
 /// Tries to move the iterator forward returning `true` if there is a dollar sign. If not, then the
 /// iterator is not modified and the result is `false`.
 fn try_eat_dollar(iter: &mut RefTokenTreeCursor<'_>) -> bool {
- if let Some(TokenTree::Token(token::Token { kind: token::Dollar, .. }, _)) = iter.look_ahead(0)
- {
+ if let Some(TokenTree::Token(Token { kind: token::Dollar, .. }, _)) = iter.look_ahead(0) {
  let _ = iter.next();
  return true;
  }
@@ -232,8 +265,7 @@ fn eat_dollar<'psess>(
  psess: &'psess ParseSess,
  span: Span,
 ) -> PResult<'psess, ()> {
- if let Some(TokenTree::Token(token::Token { kind: token::Dollar, .. }, _)) = iter.look_ahead(0)
- {
+ if let Some(TokenTree::Token(Token { kind: token::Dollar, .. }, _)) = iter.look_ahead(0) {
  let _ = iter.next();
  return Ok(());
  }

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -11,11 +11,13 @@ use rustc_ast::token::{self, Delimiter, Token, TokenKind};
 use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{pluralize, Diag, DiagCtxtHandle, PResult};
+use rustc_parse::lexer::nfc_normalize;
 use rustc_parse::parser::ParseNtResult;
 use rustc_session::parse::ParseSess;
+use rustc_session::parse::SymbolGallery;
 use rustc_span::hygiene::{LocalExpnId, Transparency};
 use rustc_span::symbol::{sym, Ident, MacroRulesNormalizedIdent};
-use rustc_span::{with_metavar_spans, Span, Symbol, SyntaxContext};
+use rustc_span::{with_metavar_spans, Span, SyntaxContext};
 use smallvec::{smallvec, SmallVec};
 use std::mem;
 
@@ -312,7 +314,16 @@ pub(super) fn transcribe<'a>(
 
  // Replace meta-variable expressions with the result of their expansion.
  mbe::TokenTree::MetaVarExpr(sp, expr) => {
- transcribe_metavar_expr(dcx, expr, interp, &mut marker, &repeats, &mut result, sp)?;
+ transcribe_metavar_expr(
+ dcx,
+ expr,
+ interp,
+ &mut marker,
+ &repeats,
+ &mut result,
+ sp,
+ &psess.symbol_gallery,
+ )?;
  }
 
  // If we are entering a new delimiter, we push its contents to the `stack` to be
@@ -669,6 +680,7 @@ fn transcribe_metavar_expr<'a>(
  repeats: &[(usize, usize)],
  result: &mut Vec<TokenTree>,
  sp: &DelimSpan,
+ symbol_gallery: &SymbolGallery,
 ) -> PResult<'a, ()> {
  let mut visited_span = || {
  let mut span = sp.entire();
@@ -680,16 +692,26 @@ fn transcribe_metavar_expr<'a>(
  let mut concatenated = String::new();
  for element in elements.into_iter() {
  let string = match element {
- MetaVarExprConcatElem::Ident(ident) => ident.to_string(),
- MetaVarExprConcatElem::Var(ident) => extract_ident(dcx, *ident, interp)?,
+ MetaVarExprConcatElem::Ident(elem) => elem.to_string(),
+ MetaVarExprConcatElem::Literal(elem) => elem.as_str().into(),
+ MetaVarExprConcatElem::Var(elem) => extract_ident(dcx, *elem, interp)?,
  };
  concatenated.push_str(&string);
  }
+ let symbol = nfc_normalize(&concatenated);
+ let concatenated_span = visited_span();
+ if !rustc_lexer::is_ident(symbol.as_str()) {
+ return Err(dcx.struct_span_err(
+ concatenated_span,
+ "`${concat(..)}` is not generating a valid identifier",
+ ));
+ }
+ symbol_gallery.insert(symbol, concatenated_span);
  // The current implementation marks the span as coming from the macro regardless of
  // contexts of the concatenated identifiers but this behavior may change in the
  // future.
  result.push(TokenTree::Token(
- Token::from_ast_ident(Ident::new(Symbol::intern(&concatenated), visited_span())),
+ Token::from_ast_ident(Ident::new(symbol, concatenated_span)),
  Spacing::Alone,
  ));
  }

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -26,22 +26,20 @@ fn equate_intrinsic_type<'tcx>(
  n_cts: usize,
  sig: ty::PolyFnSig<'tcx>,
 ) {
- let (own_counts, span) = match tcx.hir_node_by_def_id(def_id) {
+ let (generics, span) = match tcx.hir_node_by_def_id(def_id) {
  hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, generics, _), .. })
  | hir::Node::ForeignItem(hir::ForeignItem {
  kind: hir::ForeignItemKind::Fn(.., generics, _),
  ..
- }) => {
- let own_counts = tcx.generics_of(def_id).own_counts();
- (own_counts, generics.span)
- }
+ }) => (tcx.generics_of(def_id), generics.span),
  _ => {
  struct_span_code_err!(tcx.dcx(), span, E0622, "intrinsic must be a function")
  .with_span_label(span, "expected a function")
  .emit();
  return;
  }
  };
+ let own_counts = generics.own_counts();
 
  let gen_count_ok = |found: usize, expected: usize, descr: &str| -> bool {
  if found != expected {
@@ -57,9 +55,17 @@ fn equate_intrinsic_type<'tcx>(
  }
  };
 
+ // the host effect param should be invisible as it shouldn't matter
+ // whether effects is enabled for the intrinsic provider crate.
+ let consts_count = if generics.host_effect_index.is_some() {
+ own_counts.consts - 1
+ } else {
+ own_counts.consts
+ };
+
  if gen_count_ok(own_counts.lifetimes, n_lts, "lifetime")
  && gen_count_ok(own_counts.types, n_tps, "type")
- && gen_count_ok(own_counts.consts, n_cts, "const")
+ && gen_count_ok(consts_count, n_cts, "const")
  {
  let _ = check_function_signature(
  tcx,

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -478,7 +478,7 @@ fn check_gat_where_clauses(tcx: TyCtxt<'_>, trait_def_id: LocalDefId) {
  param_env,
  item_def_id,
  tcx.explicit_item_bounds(item_def_id)
- .instantiate_identity_iter_copied()
+ .iter_identity_copied()
  .collect::<Vec<_>>(),
  &FxIndexSet::default(),
  gat_def_id,
@@ -1205,17 +1205,16 @@ fn check_associated_type_bounds(wfcx: &WfCheckingCtxt<'_, '_>, item: ty::AssocIt
  let bounds = wfcx.tcx().explicit_item_bounds(item.def_id);
 
  debug!("check_associated_type_bounds: bounds={:?}", bounds);
- let wf_obligations =
- bounds.instantiate_identity_iter_copied().flat_map(|(bound, bound_span)| {
- let normalized_bound = wfcx.normalize(span, None, bound);
- traits::wf::clause_obligations(
- wfcx.infcx,
- wfcx.param_env,
- wfcx.body_def_id,
- normalized_bound,
- bound_span,
- )
- });
+ let wf_obligations = bounds.iter_identity_copied().flat_map(|(bound, bound_span)| {
+ let normalized_bound = wfcx.normalize(span, None, bound);
+ traits::wf::clause_obligations(
+ wfcx.infcx,
+ wfcx.param_env,
+ wfcx.body_def_id,
+ normalized_bound,
+ bound_span,
+ )
+ });
 
  wfcx.register_obligations(wf_obligations);
 }

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -286,7 +286,7 @@ fn orphan_check<'tcx>(
  tcx: TyCtxt<'tcx>,
  impl_def_id: LocalDefId,
  mode: OrphanCheckMode,
-) -> Result<(), OrphanCheckErr<'tcx, FxIndexSet<DefId>>> {
+) -> Result<(), OrphanCheckErr<TyCtxt<'tcx>, FxIndexSet<DefId>>> {
  // We only accept this routine to be invoked on implementations
  // of a trait, not inherent implementations.
  let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();
@@ -326,17 +326,16 @@ fn orphan_check<'tcx>(
  ty
  };
 
- Ok(ty)
+ Ok::<_, !>(ty)
  };
 
- let Ok(result) = traits::orphan_check_trait_ref::<!>(
+ let result = traits::orphan_check_trait_ref(
  &infcx,
  trait_ref,
  traits::InCrate::Local { mode },
  lazily_normalize_ty,
- ) else {
- unreachable!()
- };
+ )
+ .into_ok();
 
  // (2) Try to map the remaining inference vars back to generic params.
  result.map_err(|err| match err {
@@ -369,7 +368,7 @@ fn emit_orphan_check_error<'tcx>(
  tcx: TyCtxt<'tcx>,
  trait_ref: ty::TraitRef<'tcx>,
  impl_def_id: LocalDefId,
- err: traits::OrphanCheckErr<'tcx, FxIndexSet<DefId>>,
+ err: traits::OrphanCheckErr<TyCtxt<'tcx>, FxIndexSet<DefId>>,
 ) -> ErrorGuaranteed {
  match err {
  traits::OrphanCheckErr::NonLocalInputType(tys) => {
@@ -482,7 +481,7 @@ fn emit_orphan_check_error<'tcx>(
 
 fn lint_uncovered_ty_params<'tcx>(
  tcx: TyCtxt<'tcx>,
- UncoveredTyParams { uncovered, local_ty }: UncoveredTyParams<'tcx, FxIndexSet<DefId>>,
+ UncoveredTyParams { uncovered, local_ty }: UncoveredTyParams<TyCtxt<'tcx>, FxIndexSet<DefId>>,
  impl_def_id: LocalDefId,
 ) {
  let hir_id = tcx.local_def_id_to_hir_id(impl_def_id);

compiler/rustc_hir_analysis/src/collect.rs

@@ -1201,6 +1201,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
 
  let is_marker = tcx.has_attr(def_id, sym::marker);
  let rustc_coinductive = tcx.has_attr(def_id, sym::rustc_coinductive);
+ let is_fundamental = tcx.has_attr(def_id, sym::fundamental);
 
  // FIXME: We could probably do way better attribute validation here.
  let mut skip_array_during_method_dispatch = false;
@@ -1352,6 +1353,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
  has_auto_impl: is_auto,
  is_marker,
  is_coinductive: rustc_coinductive || is_auto,
+ is_fundamental,
  skip_array_during_method_dispatch,
  skip_boxed_slice_during_method_dispatch,
  specialization_kind,

compiler/rustc_hir_analysis/src/lib.rs

@@ -71,6 +71,7 @@ This API is completely unstable and subject to change.
 #![feature(rustdoc_internals)]
 #![feature(slice_partition_dedup)]
 #![feature(try_blocks)]
+#![feature(unwrap_infallible)]
 // tidy-alphabetical-end
 
 #[macro_use]

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1752,10 +1752,8 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
  fcx.probe(|_| {
  let ocx = ObligationCtxt::new(fcx);
  ocx.register_obligations(
- fcx.tcx
- .item_super_predicates(rpit_def_id)
- .instantiate_identity_iter()
- .filter_map(|clause| {
+ fcx.tcx.item_super_predicates(rpit_def_id).iter_identity().filter_map(
+ |clause| {
  let predicate = clause
  .kind()
  .map_bound(|clause| match clause {
@@ -1776,7 +1774,8 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
  fcx.param_env,
  predicate,
  ))
- }),
+ },
+ ),
  );
  ocx.select_where_possible().is_empty()
  })