Auto merge of #128169 - matthiaskrgr:rollup-ylsoq30, r=matthiaskrgr

Rollup of 5 pull requests

Successful merges:

 - #127054 (Reorder trait bound modifiers *after* `for<...>` binder in trait bounds)
 - #127528 (Replace ASCII control chars with Unicode Control Pictures)
 - #127872 (Migrate `pointer-auth-link-with-c`, `c-dynamic-rlib` and `c-dynamic-dylib` `run-make` tests to rmake)
 - #128111 (Do not use question as label)
 - #128160 (Don't ICE when auto trait has assoc ty in old solver)

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

Cargo.lock

@@ -3882,7 +3882,6 @@ dependencies = [
  "termcolor",
  "termize",
  "tracing",
- "unicode-width",
  "windows",
 ]
 

compiler/rustc_ast_passes/messages.ftl

@@ -155,8 +155,6 @@ ast_passes_impl_trait_path = `impl Trait` is not allowed in path parameters
 ast_passes_incompatible_features = `{$f1}` and `{$f2}` are incompatible, using them at the same time is not allowed
  .help = remove one of these features
 
-ast_passes_incompatible_trait_bound_modifiers = `{$left}` and `{$right}` are mutually exclusive
-
 ast_passes_inherent_cannot_be = inherent impls cannot be {$annotation}
  .because = {$annotation} because of this
  .type = inherent impl for this type

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1366,17 +1366,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  {
  self.dcx().emit_err(errors::TildeConstDisallowed { span, reason });
  }
- (
- _,
- BoundConstness::Always(_) | BoundConstness::Maybe(_),
- BoundPolarity::Negative(_) | BoundPolarity::Maybe(_),
- ) => {
- self.dcx().emit_err(errors::IncompatibleTraitBoundModifiers {
- span: bound.span(),
- left: modifiers.constness.as_str(),
- right: modifiers.polarity.as_str(),
- });
- }
  _ => {}
  }
 

compiler/rustc_ast_passes/src/errors.rs

@@ -656,15 +656,6 @@ pub enum TildeConstReason {
  Item,
 }
 
-#[derive(Diagnostic)]
-#[diag(ast_passes_incompatible_trait_bound_modifiers)]
-pub struct IncompatibleTraitBoundModifiers {
- #[primary_span]
- pub span: Span,
- pub left: &'static str,
- pub right: &'static str,
-}
-
 #[derive(Diagnostic)]
 #[diag(ast_passes_const_and_async)]
 pub struct ConstAndAsync {

compiler/rustc_errors/Cargo.toml

@@ -26,7 +26,6 @@ serde_json = "1.0.59"
 termcolor = "1.2.0"
 termize = "0.1.1"
 tracing = "0.1"
-unicode-width = "0.1.4"
 # tidy-alphabetical-end
 
 [target.'cfg(windows)'.dependencies.windows]

compiler/rustc_errors/src/emitter.rs

@@ -8,7 +8,7 @@
 //! The output types are defined in `rustc_session::config::ErrorOutputType`.
 
 use rustc_span::source_map::SourceMap;
-use rustc_span::{FileLines, FileName, SourceFile, Span};
+use rustc_span::{char_width, FileLines, FileName, SourceFile, Span};
 
 use crate::snippet::{
  Annotation, AnnotationColumn, AnnotationType, Line, MultilineAnnotation, Style, StyledString,
@@ -677,10 +677,7 @@ impl HumanEmitter {
  .skip(left)
  .take_while(|ch| {
  // Make sure that the trimming on the right will fall within the terminal width.
- // FIXME: `unicode_width` sometimes disagrees with terminals on how wide a `char`
- // is. For now, just accept that sometimes the code line will be longer than
- // desired.
- let next = unicode_width::UnicodeWidthChar::width(*ch).unwrap_or(1);
+ let next = char_width(*ch);
  if taken + next > right - left {
  return false;
  }
@@ -742,11 +739,7 @@ impl HumanEmitter {
  let left = margin.left(source_string.len());
 
  // Account for unicode characters of width !=0 that were removed.
- let left = source_string
- .chars()
- .take(left)
- .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
- .sum();
+ let left = source_string.chars().take(left).map(|ch| char_width(ch)).sum();
 
  self.draw_line(
  buffer,
@@ -2039,7 +2032,7 @@ impl HumanEmitter {
  let sub_len: usize =
  if is_whitespace_addition { &part.snippet } else { part.snippet.trim() }
  .chars()
- .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
+ .map(|ch| char_width(ch))
  .sum();
 
  let offset: isize = offsets
@@ -2076,11 +2069,8 @@ impl HumanEmitter {
  }
 
  // length of the code after substitution
- let full_sub_len = part
- .snippet
- .chars()
- .map(|ch| unicode_width::UnicodeWidthChar::width(ch).unwrap_or(1))
- .sum::<usize>() as isize;
+ let full_sub_len =
+ part.snippet.chars().map(|ch| char_width(ch)).sum::<usize>() as isize;
 
  // length of the code to be substituted
  let snippet_len = span_end_pos as isize - span_start_pos as isize;
@@ -2568,18 +2558,53 @@ fn num_decimal_digits(num: usize) -> usize {
 }
 
 // We replace some characters so the CLI output is always consistent and underlines aligned.
+// Keep the following list in sync with `rustc_span::char_width`.
 const OUTPUT_REPLACEMENTS: &[(char, &str)] = &[
- ('\t', " "), // We do our own tab replacement
+ ('\t', " "),  // We do our own tab replacement
  ('\u{200D}', ""), // Replace ZWJ with nothing for consistent terminal output of grapheme clusters.
- ('\u{202A}', ""), // The following unicode text flow control characters are inconsistently
- ('\u{202B}', ""), // supported across CLIs and can cause confusion due to the bytes on disk
- ('\u{202D}', ""), // not corresponding to the visible source code, so we replace them always.
- ('\u{202E}', ""),
- ('\u{2066}', ""),
- ('\u{2067}', ""),
- ('\u{2068}', ""),
- ('\u{202C}', ""),
- ('\u{2069}', ""),
+ ('\u{202A}', "�"), // The following unicode text flow control characters are inconsistently
+ ('\u{202B}', "�"), // supported across CLIs and can cause confusion due to the bytes on disk
+ ('\u{202D}', "�"), // not corresponding to the visible source code, so we replace them always.
+ ('\u{202E}', "�"),
+ ('\u{2066}', "�"),
+ ('\u{2067}', "�"),
+ ('\u{2068}', "�"),
+ ('\u{202C}', "�"),
+ ('\u{2069}', "�"),
+ // In terminals without Unicode support the following will be garbled, but in *all* terminals
+ // the underlying codepoint will be as well. We could gate this replacement behind a "unicode
+ // support" gate.
+ ('\u{0000}', "␀"),
+ ('\u{0001}', "␁"),
+ ('\u{0002}', "␂"),
+ ('\u{0003}', "␃"),
+ ('\u{0004}', "␄"),
+ ('\u{0005}', "␅"),
+ ('\u{0006}', "␆"),
+ ('\u{0007}', "␇"),
+ ('\u{0008}', "␈"),
+ ('\u{000B}', "␋"),
+ ('\u{000C}', "␌"),
+ ('\u{000D}', "␍"),
+ ('\u{000E}', "␎"),
+ ('\u{000F}', "␏"),
+ ('\u{0010}', "␐"),
+ ('\u{0011}', "␑"),
+ ('\u{0012}', "␒"),
+ ('\u{0013}', "␓"),
+ ('\u{0014}', "␔"),
+ ('\u{0015}', "␕"),
+ ('\u{0016}', "␖"),
+ ('\u{0017}', "␗"),
+ ('\u{0018}', "␘"),
+ ('\u{0019}', "␙"),
+ ('\u{001A}', "␚"),
+ ('\u{001B}', "␛"),
+ ('\u{001C}', "␜"),
+ ('\u{001D}', "␝"),
+ ('\u{001E}', "␞"),
+ ('\u{001F}', "␟"),
+ ('\u{007F}', "␡"),
 ];
 
 fn normalize_whitespace(str: &str) -> String {

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1728,7 +1728,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
  source_len,
  lines,
  multibyte_chars,
- non_narrow_chars,
  normalized_pos,
  stable_id,
  ..
@@ -1780,7 +1779,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
  self.cnum,
  lines,
  multibyte_chars,
- non_narrow_chars,
  normalized_pos,
  source_file_index,
  );

compiler/rustc_parse/messages.ftl

@@ -53,6 +53,12 @@ parse_bare_cr = {$double_quotes ->
 
 parse_bare_cr_in_raw_string = bare CR not allowed in raw string
 
+parse_binder_and_polarity = `for<...>` binder not allowed with `{$polarity}` trait polarity modifier
+ .label = there is not a well-defined meaning for a higher-ranked `{$polarity}` trait
+
+parse_binder_before_modifiers = `for<...>` binder should be placed before trait bound modifiers
+ .label = place the `for<...>` binder before any modifiers
+
 parse_bounds_not_allowed_on_trait_aliases = bounds are not allowed on trait aliases
 
 parse_box_not_pat = expected pattern, found {$descr}
@@ -577,6 +583,9 @@ parse_missing_trait_in_trait_impl = missing trait in a trait impl
 parse_modifier_lifetime = `{$modifier}` may only modify trait bounds, not lifetime bounds
  .suggestion = remove the `{$modifier}`
 
+parse_modifiers_and_polarity = `{$modifiers_concatenated}` trait not allowed with `{$polarity}` trait polarity modifier
+ .label = there is not a well-defined meaning for a `{$modifiers_concatenated} {$polarity}` trait
+
 parse_more_than_one_char = character literal may only contain one codepoint
  .followed_by = this `{$chr}` is followed by the combining {$len ->
  [one] mark

compiler/rustc_parse/src/errors.rs

@@ -3212,3 +3212,33 @@ pub struct UnsafeAttrOutsideUnsafeSuggestion {
  #[suggestion_part(code = ")")]
  pub right: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(parse_binder_before_modifiers)]
+pub struct BinderBeforeModifiers {
+ #[primary_span]
+ pub binder_span: Span,
+ #[label]
+ pub modifiers_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_binder_and_polarity)]
+pub struct BinderAndPolarity {
+ #[primary_span]
+ pub polarity_span: Span,
+ #[label]
+ pub binder_span: Span,
+ pub polarity: &'static str,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_modifiers_and_polarity)]
+pub struct PolarityAndModifiers {
+ #[primary_span]
+ pub polarity_span: Span,
+ #[label]
+ pub modifiers_span: Span,
+ pub polarity: &'static str,
+ pub modifiers_concatenated: String,
+}

compiler/rustc_parse/src/parser/ty.rs

@@ -935,9 +935,14 @@ impl<'a> Parser<'a> {
  /// If no modifiers are present, this does not consume any tokens.
  ///
  /// ```ebnf
- /// TRAIT_BOUND_MODIFIERS = [["~"] "const"] ["async"] ["?" | "!"]
+ /// CONSTNESS = [["~"] "const"]
+ /// ASYNCNESS = ["async"]
+ /// POLARITY = ["?" | "!"]
  /// ```
+ ///
+ /// See `parse_generic_ty_bound` for the complete grammar of trait bound modifiers.
  fn parse_trait_bound_modifiers(&mut self) -> PResult<'a, TraitBoundModifiers> {
+ let modifier_lo = self.token.span;
  let constness = if self.eat(&token::Tilde) {
  let tilde = self.prev_token.span;
  self.expect_keyword(kw::Const)?;
@@ -970,6 +975,7 @@ impl<'a> Parser<'a> {
  } else {
  BoundAsyncness::Normal
  };
+ let modifier_hi = self.prev_token.span;
 
  let polarity = if self.eat(&token::Question) {
  BoundPolarity::Maybe(self.prev_token.span)
@@ -980,13 +986,40 @@ impl<'a> Parser<'a> {
  BoundPolarity::Positive
  };
 
+ // Enforce the mutual-exclusivity of `const`/`async` and `?`/`!`.
+ match polarity {
+ BoundPolarity::Positive => {
+ // All trait bound modifiers allowed to combine with positive polarity
+ }
+ BoundPolarity::Maybe(polarity_span) | BoundPolarity::Negative(polarity_span) => {
+ match (asyncness, constness) {
+ (BoundAsyncness::Normal, BoundConstness::Never) => {
+ // Ok, no modifiers.
+ }
+ (_, _) => {
+ let constness = constness.as_str();
+ let asyncness = asyncness.as_str();
+ let glue =
+ if !constness.is_empty() && !asyncness.is_empty() { " " } else { "" };
+ let modifiers_concatenated = format!("{constness}{glue}{asyncness}");
+ self.dcx().emit_err(errors::PolarityAndModifiers {
+ polarity_span,
+ polarity: polarity.as_str(),
+ modifiers_span: modifier_lo.to(modifier_hi),
+ modifiers_concatenated,
+ });
+ }
+ }
+ }
+ }
+
  Ok(TraitBoundModifiers { constness, asyncness, polarity })
  }
 
  /// Parses a type bound according to:
  /// ```ebnf
  /// TY_BOUND = TY_BOUND_NOPAREN | (TY_BOUND_NOPAREN)
- /// TY_BOUND_NOPAREN = [TRAIT_BOUND_MODIFIERS] [for<LT_PARAM_DEFS>] SIMPLE_PATH
+ /// TY_BOUND_NOPAREN = [for<GENERIC_PARAMS> CONSTNESS ASYNCNESS | POLARITY] SIMPLE_PATH
  /// ```
  ///
  /// For example, this grammar accepts `for<'a: 'b> ~const ?m::Trait<'a>`.
@@ -996,16 +1029,37 @@ impl<'a> Parser<'a> {
  has_parens: bool,
  leading_token: &Token,
  ) -> PResult<'a, GenericBound> {
- let modifiers = self.parse_trait_bound_modifiers()?;
  let (mut lifetime_defs, binder_span) = self.parse_late_bound_lifetime_defs()?;
 
+ let modifiers_lo = self.token.span;
+ let modifiers = self.parse_trait_bound_modifiers()?;
+ let modifiers_span = modifiers_lo.to(self.prev_token.span);
+
+ if let Some(binder_span) = binder_span {
+ match modifiers.polarity {
+ BoundPolarity::Negative(polarity_span) | BoundPolarity::Maybe(polarity_span) => {
+ self.dcx().emit_err(errors::BinderAndPolarity {
+ binder_span,
+ polarity_span,
+ polarity: modifiers.polarity.as_str(),
+ });
+ }
+ BoundPolarity::Positive => {}
+ }
+ }
+
  // Recover erroneous lifetime bound with modifiers or binder.
  // e.g. `T: for<'a> 'a` or `T: ~const 'a`.
  if self.token.is_lifetime() {
  let _: ErrorGuaranteed = self.error_lt_bound_with_modifiers(modifiers, binder_span);
  return self.parse_generic_lt_bound(lo, has_parens);
  }
 
+ if let (more_lifetime_defs, Some(binder_span)) = self.parse_late_bound_lifetime_defs()? {
+ lifetime_defs.extend(more_lifetime_defs);
+ self.dcx().emit_err(errors::BinderBeforeModifiers { binder_span, modifiers_span });
+ }
+
  let mut path = if self.token.is_keyword(kw::Fn)
  && self.look_ahead(1, |tok| tok.kind == TokenKind::OpenDelim(Delimiter::Parenthesis))
  && let Some(path) = self.recover_path_from_fn()

compiler/rustc_query_system/src/ich/impls_syntax.rs

@@ -73,7 +73,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
  source_len: _,
  lines: _,
  ref multibyte_chars,
- ref non_narrow_chars,
  ref normalized_pos,
  } = *self;
 
@@ -98,11 +97,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
  char_pos.hash_stable(hcx, hasher);
  }
 
- non_narrow_chars.len().hash_stable(hcx, hasher);
- for &char_pos in non_narrow_chars.iter() {
- char_pos.hash_stable(hcx, hasher);
- }
-
  normalized_pos.len().hash_stable(hcx, hasher);
  for &char_pos in normalized_pos.iter() {
  char_pos.hash_stable(hcx, hasher);

compiler/rustc_resolve/src/diagnostics.rs

@@ -2012,7 +2012,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  )
  } else if ident.name == sym::core {
  (
- format!("maybe a missing crate `{ident}`?"),
+ format!("you might be missing crate `{ident}`"),
  Some((
  vec![(ident.span, "std".to_string())],
  "try using `std` instead of `core`".to_string(),
@@ -2021,7 +2021,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
  )
  } else if self.tcx.sess.is_rust_2015() {
  (
- format!("maybe a missing crate `{ident}`?"),
+ format!("you might be missing crate `{ident}`"),
  Some((
  vec![],
  format!(