Auto merge of rust-lang#99520 - matthiaskrgr:rollup-05uuv5s, r=matthi…

…askrgr

Rollup of 9 pull requests

Successful merges:

 - rust-lang#99212 (introduce `implied_by` in `#[unstable]` attribute)
 - rust-lang#99352 (Use `typeck_results` to avoid duplicate `ast_ty_to_ty` call)
 - rust-lang#99355 (better error for bad depth parameter on macro metavar expr)
 - rust-lang#99480 (Diagnostic width span is not added when '0$' is used as width in format strings)
 - rust-lang#99488 (compiletest: Allow using revisions with debuginfo tests.)
 - rust-lang#99489 (rustdoc UI fixes)
 - rust-lang#99508 (Avoid `Symbol` to `String` conversions)
 - rust-lang#99510 (adapt assembly/static-relocation-model test for LLVM change)
 - rust-lang#99516 (Use new tracking issue for proc_macro::tracked_*.)

Failed merges:

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

compiler/rustc_attr/src/builtin.rs

@@ -135,9 +135,42 @@ impl ConstStability {
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
 #[derive(HashStable_Generic)]
 pub enum StabilityLevel {
- // Reason for the current stability level and the relevant rust-lang issue
- Unstable { reason: Option<Symbol>, issue: Option<NonZeroU32>, is_soft: bool },
- Stable { since: Symbol, allowed_through_unstable_modules: bool },
+ /// `#[unstable]`
+ Unstable {
+ /// Reason for the current stability level.
+ reason: Option<Symbol>,
+ /// Relevant `rust-lang/rust` issue.
+ issue: Option<NonZeroU32>,
+ is_soft: bool,
+ /// If part of a feature is stabilized and a new feature is added for the remaining parts,
+ /// then the `implied_by` attribute is used to indicate which now-stable feature previously
+ /// contained a item.
+ ///
+ /// ```pseudo-Rust
+ /// #[unstable(feature = "foo", issue = "...")]
+ /// fn foo() {}
+ /// #[unstable(feature = "foo", issue = "...")]
+ /// fn foobar() {}
+ /// ```
+ ///
+ /// ...becomes...
+ ///
+ /// ```pseudo-Rust
+ /// #[stable(feature = "foo", since = "1.XX.X")]
+ /// fn foo() {}
+ /// #[unstable(feature = "foobar", issue = "...", implied_by = "foo")]
+ /// fn foobar() {}
+ /// ```
+ implied_by: Option<Symbol>,
+ },
+ /// `#[stable]`
+ Stable {
+ /// Rust release which stabilized this feature.
+ since: Symbol,
+ /// Is this item allowed to be referred to on stable, despite being contained in unstable
+ /// modules?
+ allowed_through_unstable_modules: bool,
+ },
 }
 
 impl StabilityLevel {
@@ -243,6 +276,7 @@ where
  let mut issue = None;
  let mut issue_num = None;
  let mut is_soft = false;
+ let mut implied_by = None;
  for meta in metas {
  let Some(mi) = meta.meta_item() else {
  handle_errors(
@@ -308,6 +342,11 @@ where
  }
  is_soft = true;
  }
+ sym::implied_by => {
+ if !get(mi, &mut implied_by) {
+ continue 'outer;
+ }
+ }
  _ => {
  handle_errors(
  &sess.parse_sess,
@@ -332,7 +371,7 @@ where
  );
  continue;
  }
- let level = Unstable { reason, issue: issue_num, is_soft };
+ let level = Unstable { reason, issue: issue_num, is_soft, implied_by };
  if sym::unstable == meta_name {
  stab = Some((Stability { level, feature }, attr.span));
  } else {
@@ -391,7 +430,7 @@ where
  meta.span(),
  AttrError::UnknownMetaItem(
  pprust::path_to_string(&mi.path),
- &["since", "note"],
+ &["feature", "since"],
  ),
  );
  continue 'outer;

compiler/rustc_builtin_macros/src/format.rs

@@ -485,7 +485,7 @@ impl<'a, 'b> Context<'a, 'b> {
  if let Some(span) = fmt.width_span {
  let span = self.fmtsp.from_inner(InnerSpan::new(span.start, span.end));
  match fmt.width {
- parse::CountIsParam(pos) if pos > self.num_args() => {
+ parse::CountIsParam(pos) if pos >= self.num_args() => {
  e.span_label(
  span,
  &format!(
@@ -1004,9 +1004,7 @@ fn lint_named_arguments_used_positionally(
  node_id: ast::CRATE_NODE_ID,
  lint_id: LintId::of(&NAMED_ARGUMENTS_USED_POSITIONALLY),
  diagnostic: BuiltinLintDiagnostics::NamedArgumentUsedPositionally(
- arg_span,
- span,
- symbol.to_string(),
+ arg_span, span, symbol,
  ),
  });
  }

compiler/rustc_errors/src/diagnostic.rs

@@ -390,18 +390,17 @@ impl Diagnostic {
  expected: DiagnosticStyledString,
  found: DiagnosticStyledString,
  ) -> &mut Self {
- let mut msg: Vec<_> =
- vec![("required when trying to coerce from type `".to_string(), Style::NoStyle)];
+ let mut msg: Vec<_> = vec![("required when trying to coerce from type `", Style::NoStyle)];
  msg.extend(expected.0.iter().map(|x| match *x {
- StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
- StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
+ StringPart::Normal(ref s) => (s.as_str(), Style::NoStyle),
+ StringPart::Highlighted(ref s) => (s.as_str(), Style::Highlight),
  }));
- msg.push(("` to type '".to_string(), Style::NoStyle));
+ msg.push(("` to type '", Style::NoStyle));
  msg.extend(found.0.iter().map(|x| match *x {
- StringPart::Normal(ref s) => (s.to_owned(), Style::NoStyle),
- StringPart::Highlighted(ref s) => (s.to_owned(), Style::Highlight),
+ StringPart::Normal(ref s) => (s.as_str(), Style::NoStyle),
+ StringPart::Highlighted(ref s) => (s.as_str(), Style::Highlight),
  }));
- msg.push(("`".to_string(), Style::NoStyle));
+ msg.push(("`", Style::NoStyle));
 
  // For now, just attach these as notes
  self.highlighted_note(msg);

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -512,7 +512,18 @@ fn out_of_bounds_err<'a>(
  span: Span,
  ty: &str,
 ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
- cx.struct_span_err(span, &format!("{ty} depth must be less than {max}"))
+ let msg = if max == 0 {
+ format!(
+ "meta-variable expression `{ty}` with depth parameter \
+ must be called inside of a macro repetition"
+ )
+ } else {
+ format!(
+ "depth parameter on meta-variable expression `{ty}` \
+ must be less than {max}"
+ )
+ };
+ cx.struct_span_err(span, &msg)
 }
 
 fn transcribe_metavar_expr<'a>(

compiler/rustc_lint_defs/src/lib.rs

@@ -467,7 +467,7 @@ pub enum BuiltinLintDiagnostics {
  /// If true, the lifetime will be fully elided.
  use_span: Option<(Span, bool)>,
  },
- NamedArgumentUsedPositionally(Option<Span>, Span, String),
+ NamedArgumentUsedPositionally(Option<Span>, Span, Symbol),
 }
 
 /// Lints that are buffered up early on in the `Session` before the

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -951,6 +951,13 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
  tcx.arena.alloc_from_iter(self.root.lib_features.decode(self))
  }
 
+ /// Iterates over the stability implications in the given crate (when a `#[unstable]` attribute
+ /// has an `implied_by` meta item, then the mapping from the implied feature to the actual
+ /// feature is a stability implication).
+ fn get_stability_implications(self, tcx: TyCtxt<'tcx>) -> &'tcx [(Symbol, Symbol)] {
+ tcx.arena.alloc_from_iter(self.root.stability_implications.decode(self))
+ }
+
  /// Iterates over the language items in the given crate.
  fn get_lang_items(self, tcx: TyCtxt<'tcx>) -> &'tcx [(DefId, usize)] {
  tcx.arena.alloc_from_iter(

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -291,6 +291,9 @@ provide! { <'tcx> tcx, def_id, other, cdata,
  tcx.arena.alloc_slice(&result)
  }
  defined_lib_features => { cdata.get_lib_features(tcx) }
+ stability_implications => {
+ cdata.get_stability_implications(tcx).iter().copied().collect()
+ }
  is_intrinsic => { cdata.get_is_intrinsic(def_id.index) }
  defined_lang_items => { cdata.get_lang_items(tcx) }
  diagnostic_items => { cdata.get_diagnostic_items() }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -538,6 +538,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  let lib_features = self.encode_lib_features();
  let lib_feature_bytes = self.position() - i;
 
+ // Encode the stability implications.
+ i = self.position();
+ let stability_implications = self.encode_stability_implications();
+ let stability_implications_bytes = self.position() - i;
+
  // Encode the language items.
  i = self.position();
  let lang_items = self.encode_lang_items();
@@ -686,6 +691,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  crate_deps,
  dylib_dependency_formats,
  lib_features,
+ stability_implications,
  lang_items,
  diagnostic_items,
  lang_items_missing,
@@ -710,6 +716,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  let computed_total_bytes = preamble_bytes
  + dep_bytes
  + lib_feature_bytes
+ + stability_implications_bytes
  + lang_item_bytes
  + diagnostic_item_bytes
  + native_lib_bytes
@@ -761,6 +768,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  p("preamble", preamble_bytes);
  p("dep", dep_bytes);
  p("lib feature", lib_feature_bytes);
+ p("stability_implications", stability_implications_bytes);
  p("lang item", lang_item_bytes);
  p("diagnostic item", diagnostic_item_bytes);
  p("native lib", native_lib_bytes);
@@ -1777,6 +1785,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  self.lazy_array(lib_features.to_vec())
  }
 
+ fn encode_stability_implications(&mut self) -> LazyArray<(Symbol, Symbol)> {
+ empty_proc_macro!(self);
+ let tcx = self.tcx;
+ let implications = tcx.stability_implications(LOCAL_CRATE);
+ self.lazy_array(implications.iter().map(|(k, v)| (*k, *v)))
+ }
+
  fn encode_diagnostic_items(&mut self) -> LazyArray<(Symbol, DefIndex)> {
  empty_proc_macro!(self);
  let tcx = self.tcx;

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -226,6 +226,7 @@ pub(crate) struct CrateRoot {
  crate_deps: LazyArray<CrateDep>,
  dylib_dependency_formats: LazyArray<Option<LinkagePreference>>,
  lib_features: LazyArray<(Symbol, Option<Symbol>)>,
+ stability_implications: LazyArray<(Symbol, Symbol)>,
  lang_items: LazyArray<(DefIndex, usize)>,
  lang_items_missing: LazyArray<lang_items::LangItem>,
  diagnostic_items: LazyArray<(Symbol, DefIndex)>,

compiler/rustc_middle/src/middle/mod.rs

@@ -3,23 +3,23 @@ pub mod dependency_format;
 pub mod exported_symbols;
 pub mod lang_items;
 pub mod lib_features {
- use rustc_data_structures::fx::{FxHashMap, FxHashSet};
- use rustc_span::symbol::Symbol;
+ use rustc_data_structures::fx::FxHashMap;
+ use rustc_span::{symbol::Symbol, Span};
 
  #[derive(HashStable, Debug)]
  pub struct LibFeatures {
- // A map from feature to stabilisation version.
- pub stable: FxHashMap<Symbol, Symbol>,
- pub unstable: FxHashSet<Symbol>,
+ /// A map from feature to stabilisation version.
+ pub stable: FxHashMap<Symbol, (Symbol, Span)>,
+ pub unstable: FxHashMap<Symbol, Span>,
  }
 
  impl LibFeatures {
  pub fn to_vec(&self) -> Vec<(Symbol, Option<Symbol>)> {
  let mut all_features: Vec<_> = self
  .stable
  .iter()
- .map(|(f, s)| (*f, Some(*s)))
- .chain(self.unstable.iter().map(|f| (*f, None)))
+ .map(|(f, (s, _))| (*f, Some(*s)))
+ .chain(self.unstable.iter().map(|(f, _)| (*f, None)))
  .collect();
  all_features.sort_unstable_by(|a, b| a.0.as_str().partial_cmp(b.0.as_str()).unwrap());
  all_features

compiler/rustc_middle/src/middle/stability.rs

@@ -62,6 +62,19 @@ pub struct Index {
  pub stab_map: FxHashMap<LocalDefId, Stability>,
  pub const_stab_map: FxHashMap<LocalDefId, ConstStability>,
  pub depr_map: FxHashMap<LocalDefId, DeprecationEntry>,
+ /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
+ /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
+ /// exists, then this map will have a `impliee -> implier` entry.
+ ///
+ /// This mapping is necessary unless both the `#[stable]` and `#[unstable]` attributes should
+ /// specify their implications (both `implies` and `implied_by`). If only one of the two
+ /// attributes do (as in the current implementation, `implied_by` in `#[unstable]`), then this
+ /// mapping is necessary for diagnostics. When a "unnecessary feature attribute" error is
+ /// reported, only the `#[stable]` attribute information is available, so the map is necessary
+ /// to know that the feature implies another feature. If it were reversed, and the `#[stable]`
+ /// attribute had an `implies` meta item, then a map would be necessary when avoiding a "use of
+ /// unstable feature" error for a feature that was implied.
+ pub implications: FxHashMap<Symbol, Symbol>,
 }
 
 impl Index {
@@ -423,7 +436,9 @@ impl<'tcx> TyCtxt<'tcx> {
 
  match stability {
  Some(Stability {
- level: attr::Unstable { reason, issue, is_soft }, feature, ..
+ level: attr::Unstable { reason, issue, is_soft, implied_by },
+ feature,
+ ..
  }) => {
  if span.allows_unstable(feature) {
  debug!("stability: skipping span={:?} since it is internal", span);
@@ -433,6 +448,13 @@ impl<'tcx> TyCtxt<'tcx> {
  return EvalResult::Allow;
  }
 
+ // If this item was previously part of a now-stabilized feature which is still
+ // active (i.e. the user hasn't removed the attribute for the stabilized feature
+ // yet) then allow use of this item.
+ if let Some(implied_by) = implied_by && self.features().active(implied_by) {
+ return EvalResult::Allow;
+ }
+
  // When we're compiling the compiler itself we may pull in
  // crates from crates.io, but those crates may depend on other
  // crates also pulled in from crates.io. We want to ideally be

compiler/rustc_middle/src/query/mod.rs

@@ -1634,11 +1634,15 @@ rustc_queries! {
  storage(ArenaCacheSelector<'tcx>)
  desc { "calculating the lib features map" }
  }
- query defined_lib_features(_: CrateNum)
- -> &'tcx [(Symbol, Option<Symbol>)] {
+ query defined_lib_features(_: CrateNum) -> &'tcx [(Symbol, Option<Symbol>)] {
  desc { "calculating the lib features defined in a crate" }
  separate_provide_extern
  }
+ query stability_implications(_: CrateNum) -> FxHashMap<Symbol, Symbol> {
+ storage(ArenaCacheSelector<'tcx>)
+ desc { "calculating the implications between `#[unstable]` features defined in a crate" }
+ separate_provide_extern
+ }
  /// Whether the function is an intrinsic
  query is_intrinsic(def_id: DefId) -> bool {
  desc { |tcx| "is_intrinsic({})", tcx.def_path_str(def_id) }

compiler/rustc_parse_format/src/lib.rs

@@ -572,9 +572,10 @@ impl<'a> Parser<'a> {
  // '0' flag and then an ill-formatted format string with just a '$'
  // and no count, but this is better if we instead interpret this as
  // no '0' flag and '0$' as the width instead.
- if self.consume('$') {
+ if let Some(end) = self.consume_pos('$') {
  spec.width = CountIsParam(0);
  havewidth = true;
+ spec.width_span = Some(self.to_span_index(end - 1).to(self.to_span_index(end + 1)));
  } else {
  spec.flags |= 1 << (FlagSignAwareZeroPad as u32);
  }

compiler/rustc_parse_format/src/tests.rs

@@ -178,6 +178,23 @@ fn format_counts() {
  },
  })],
  );
+ same(
+ "{1:0$.10x}",
+ &[NextArgument(Argument {
+ position: ArgumentIs(1),
+ format: FormatSpec {
+ fill: None,
+ align: AlignUnknown,
+ flags: 0,
+ precision: CountIs(10),
+ width: CountIsParam(0),
+ precision_span: None,
+ width_span: Some(InnerSpan::new(4, 6)),
+ ty: "x",
+ ty_span: None,
+ },
+ })],
+ );
  same(
  "{:.*x}",
  &[NextArgument(Argument {