Rollup of 8 pull requests

compiler/rustc_ast/src/ast.rs

@@ -1846,7 +1846,7 @@ pub enum LitKind {
  /// A boolean literal (`true`, `false`).
  Bool(bool),
  /// Placeholder for a literal that wasn't well-formed in some way.
- Err,
+ Err(ErrorGuaranteed),
 }
 
 impl LitKind {
@@ -1893,7 +1893,7 @@ impl LitKind {
  | LitKind::Int(_, LitIntType::Unsuffixed)
  | LitKind::Float(_, LitFloatType::Unsuffixed)
  | LitKind::Bool(..)
- | LitKind::Err => false,
+ | LitKind::Err(_) => false,
  }
  }
 }

compiler/rustc_ast/src/token.rs

@@ -13,7 +13,7 @@ use rustc_macros::HashStable_Generic;
 use rustc_span::symbol::{kw, sym};
 #[allow(hidden_glob_reexports)]
 use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::{edition::Edition, Span, DUMMY_SP};
+use rustc_span::{edition::Edition, ErrorGuaranteed, Span, DUMMY_SP};
 use std::borrow::Cow;
 use std::fmt;
 
@@ -75,7 +75,7 @@ pub enum LitKind {
  ByteStrRaw(u8), // raw byte string delimited by `n` hash symbols
  CStr,
  CStrRaw(u8),
- Err,
+ Err(ErrorGuaranteed),
 }
 
 /// A literal token.
@@ -144,7 +144,7 @@ impl fmt::Display for Lit {
  CStrRaw(n) => {
  write!(f, "cr{delim}\"{symbol}\"{delim}", delim = "#".repeat(n as usize))?
  }
- Integer | Float | Bool | Err => write!(f, "{symbol}")?,
+ Integer | Float | Bool | Err(_) => write!(f, "{symbol}")?,
  }
 
  if let Some(suffix) = suffix {
@@ -159,7 +159,7 @@ impl LitKind {
  /// An English article for the literal token kind.
  pub fn article(self) -> &'static str {
  match self {
- Integer | Err => "an",
+ Integer | Err(_) => "an",
  _ => "a",
  }
  }
@@ -174,12 +174,12 @@ impl LitKind {
  Str | StrRaw(..) => "string",
  ByteStr | ByteStrRaw(..) => "byte string",
  CStr | CStrRaw(..) => "C string",
- Err => "error",
+ Err(_) => "error",
  }
  }
 
  pub(crate) fn may_have_suffix(self) -> bool {
- matches!(self, Integer | Float | Err)
+ matches!(self, Integer | Float | Err(_))
  }
 }
 

compiler/rustc_ast/src/util/literal.rs

@@ -31,20 +31,21 @@ pub fn escape_byte_str_symbol(bytes: &[u8]) -> Symbol {
 
 #[derive(Debug)]
 pub enum LitError {
- LexerError,
- InvalidSuffix,
- InvalidIntSuffix,
- InvalidFloatSuffix,
- NonDecimalFloat(u32),
- IntTooLarge(u32),
+ InvalidSuffix(Symbol),
+ InvalidIntSuffix(Symbol),
+ InvalidFloatSuffix(Symbol),
+ NonDecimalFloat(u32), // u32 is the base
+ IntTooLarge(u32), // u32 is the base
 }
 
 impl LitKind {
  /// Converts literal token into a semantic literal.
  pub fn from_token_lit(lit: token::Lit) -> Result<LitKind, LitError> {
  let token::Lit { kind, symbol, suffix } = lit;
- if suffix.is_some() && !kind.may_have_suffix() {
- return Err(LitError::InvalidSuffix);
+ if let Some(suffix) = suffix
+ && !kind.may_have_suffix()
+ {
+ return Err(LitError::InvalidSuffix(suffix));
  }
 
  // For byte/char/string literals, chars and escapes have already been
@@ -145,7 +146,7 @@ impl LitKind {
  buf.push(0);
  LitKind::CStr(buf.into(), StrStyle::Raw(n))
  }
- token::Err => LitKind::Err,
+ token::Err(guar) => LitKind::Err(guar),
  })
  }
 }
@@ -202,7 +203,7 @@ impl fmt::Display for LitKind {
  }
  }
  LitKind::Bool(b) => write!(f, "{}", if b { "true" } else { "false" })?,
- LitKind::Err => {
+ LitKind::Err(_) => {
  // This only shows up in places like `-Zunpretty=hir` output, so we
  // don't bother to produce something useful.
  write!(f, "<bad-literal>")?;
@@ -238,7 +239,7 @@ impl MetaItemLit {
  LitKind::Char(_) => token::Char,
  LitKind::Int(..) => token::Integer,
  LitKind::Float(..) => token::Float,
- LitKind::Err => token::Err,
+ LitKind::Err(guar) => token::Err(guar),
  };
 
  token::Lit::new(kind, self.symbol, self.suffix)
@@ -272,12 +273,12 @@ fn filtered_float_lit(
  return Err(LitError::NonDecimalFloat(base));
  }
  Ok(match suffix {
- Some(suf) => LitKind::Float(
+ Some(suffix) => LitKind::Float(
  symbol,
- ast::LitFloatType::Suffixed(match suf {
+ ast::LitFloatType::Suffixed(match suffix {
  sym::f32 => ast::FloatTy::F32,
  sym::f64 => ast::FloatTy::F64,
- _ => return Err(LitError::InvalidFloatSuffix),
+ _ => return Err(LitError::InvalidFloatSuffix(suffix)),
  }),
  ),
  None => LitKind::Float(symbol, ast::LitFloatType::Unsuffixed),
@@ -318,17 +319,13 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitErr
  // `1f64` and `2f32` etc. are valid float literals, and
  // `fxxx` looks more like an invalid float literal than invalid integer literal.
  _ if suf.as_str().starts_with('f') => return filtered_float_lit(symbol, suffix, base),
- _ => return Err(LitError::InvalidIntSuffix),
+ _ => return Err(LitError::InvalidIntSuffix(suf)),
  },
  _ => ast::LitIntType::Unsuffixed,
  };
 
  let s = &s[if base != 10 { 2 } else { 0 }..];
- u128::from_str_radix(s, base).map(|i| LitKind::Int(i.into(), ty)).map_err(|_| {
- // Small bases are lexed as if they were base 10, e.g, the string
- // might be `0b10201`. This will cause the conversion above to fail,
- // but these kinds of errors are already reported by the lexer.
- let from_lexer = base < 10 && s.chars().any(|c| c.to_digit(10).is_some_and(|d| d >= base));
- if from_lexer { LitError::LexerError } else { LitError::IntTooLarge(base) }
- })
+ u128::from_str_radix(s, base)
+ .map(|i| LitKind::Int(i.into(), ty))
+ .map_err(|_| LitError::IntTooLarge(base))
 }

compiler/rustc_ast_lowering/src/expr.rs

@@ -124,8 +124,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
  let lit_kind = match LitKind::from_token_lit(*token_lit) {
  Ok(lit_kind) => lit_kind,
  Err(err) => {
- report_lit_error(&self.tcx.sess.parse_sess, err, *token_lit, e.span);
- LitKind::Err
+ let guar = report_lit_error(
+ &self.tcx.sess.parse_sess,
+ err,
+ *token_lit,
+ e.span,
+ );
+ LitKind::Err(guar)
  }
  };
  let lit = self.arena.alloc(respan(self.lower_span(e.span), lit_kind));

compiler/rustc_ast_lowering/src/lib.rs

@@ -966,10 +966,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  {
  lit
  } else {
+ let guar = self.dcx().has_errors().unwrap();
  MetaItemLit {
  symbol: kw::Empty,
  suffix: None,
- kind: LitKind::Err,
+ kind: LitKind::Err(guar),
  span: DUMMY_SP,
  }
  };

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -254,7 +254,7 @@ fn literal_to_string(lit: token::Lit) -> String {
  token::CStrRaw(n) => {
  format!("cr{delim}\"{symbol}\"{delim}", delim = "#".repeat(n as usize))
  }
- token::Integer | token::Float | token::Bool | token::Err => symbol.to_string(),
+ token::Integer | token::Float | token::Bool | token::Err(_) => symbol.to_string(),
  };
 
  if let Some(suffix) = suffix {

compiler/rustc_builtin_macros/src/concat.rs

@@ -40,7 +40,7 @@ pub fn expand_concat(
  cx.dcx().emit_err(errors::ConcatBytestr { span: e.span });
  has_errors = true;
  }
- Ok(ast::LitKind::Err) => {
+ Ok(ast::LitKind::Err(_)) => {
  has_errors = true;
  }
  Err(err) => {

compiler/rustc_builtin_macros/src/concat_bytes.rs

@@ -44,7 +44,7 @@ fn invalid_type_err(
  Ok(ast::LitKind::Bool(_)) => {
  dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "boolean", sugg: None });
  }
- Ok(ast::LitKind::Err) => {}
+ Ok(ast::LitKind::Err(_)) => {}
  Ok(ast::LitKind::Int(_, _)) if !is_nested => {
  let sugg =
  snippet.map(|snippet| ConcatBytesInvalidSuggestion::IntLit { span: span, snippet });

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -266,6 +266,10 @@ pub fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
  ("riscv32" | "riscv64", "fast-unaligned-access") if get_version().0 <= 17 => {
  LLVMFeature::new("unaligned-scalar-mem")
  }
+ // For LLVM 18, enable the evex512 target feature if a avx512 target feature is enabled.
+ ("x86", s) if get_version().0 >= 18 && s.starts_with("avx512") => {
+ LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512"))
+ }
  (_, s) => LLVMFeature::new(s),
  }
 }

compiler/rustc_errors/src/emitter.rs

@@ -1743,9 +1743,17 @@ impl HumanEmitter {
  buffer.append(0, level.to_str(), Style::Level(*level));
  buffer.append(0, ": ", Style::HeaderMsg);
 
+ let mut msg = vec![(suggestion.msg.to_owned(), Style::NoStyle)];
+ if suggestions
+ .iter()
+ .take(MAX_SUGGESTIONS)
+ .any(|(_, _, _, only_capitalization)| *only_capitalization)
+ {
+ msg.push((" (notice the capitalization difference)".into(), Style::NoStyle));
+ }
  self.msgs_to_buffer(
  &mut buffer,
- &[(suggestion.msg.to_owned(), Style::NoStyle)],
+ &msg,
  args,
  max_line_num_len,
  "suggestion",
@@ -1754,12 +1762,8 @@ impl HumanEmitter {
 
  let mut row_num = 2;
  draw_col_separator_no_space(&mut buffer, 1, max_line_num_len + 1);
- let mut notice_capitalization = false;
- for (complete, parts, highlights, only_capitalization) in
- suggestions.iter().take(MAX_SUGGESTIONS)
- {
+ for (complete, parts, highlights, _) in suggestions.iter().take(MAX_SUGGESTIONS) {
  debug!(?complete, ?parts, ?highlights);
- notice_capitalization |= only_capitalization;
 
  let has_deletion = parts.iter().any(|p| p.is_deletion(sm));
  let is_multiline = complete.lines().count() > 1;
@@ -2058,9 +2062,6 @@ impl HumanEmitter {
  let others = suggestions.len() - MAX_SUGGESTIONS;
  let msg = format!("and {} other candidate{}", others, pluralize!(others));
  buffer.puts(row_num, max_line_num_len + 3, &msg, Style::NoStyle);
- } else if notice_capitalization {
- let msg = "notice the capitalization difference";
- buffer.puts(row_num, max_line_num_len + 3, msg, Style::NoStyle);
  }
  emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
  Ok(())

compiler/rustc_errors/src/lib.rs

@@ -320,7 +320,9 @@ impl CodeSuggestion {
  // We need to keep track of the difference between the existing code and the added
  // or deleted code in order to point at the correct column *after* substitution.
  let mut acc = 0;
+ let mut only_capitalization = false;
  for part in &substitution.parts {
+ only_capitalization |= is_case_difference(sm, &part.snippet, part.span);
  let cur_lo = sm.lookup_char_pos(part.span.lo());
  if prev_hi.line == cur_lo.line {
  let mut count =
@@ -393,7 +395,6 @@ impl CodeSuggestion {
  }
  }
  highlights.push(std::mem::take(&mut line_highlight));
- let only_capitalization = is_case_difference(sm, &buf, bounding_span);
  // if the replacement already ends with a newline, don't print the next line
  if !buf.ends_with('\n') {
  push_trailing(&mut buf, prev_line.as_ref(), &prev_hi, None);

compiler/rustc_expand/src/base.rs

@@ -1266,7 +1266,7 @@ pub fn expr_to_spanned_string<'a>(
  );
  Some((err, true))
  }
- Ok(ast::LitKind::Err) => None,
+ Ok(ast::LitKind::Err(_)) => None,
  Err(err) => {
  report_lit_error(&cx.sess.parse_sess, err, token_lit, expr.span);
  None

compiler/rustc_expand/src/proc_macro_server.rs

@@ -10,7 +10,7 @@ use rustc_ast::util::literal::escape_byte_str_symbol;
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
-use rustc_errors::{MultiSpan, PResult};
+use rustc_errors::{ErrorGuaranteed, MultiSpan, PResult};
 use rustc_parse::lexer::nfc_normalize;
 use rustc_parse::parse_stream_from_source_str;
 use rustc_session::parse::ParseSess;
@@ -63,7 +63,12 @@ impl FromInternal<token::LitKind> for LitKind {
  token::ByteStrRaw(n) => LitKind::ByteStrRaw(n),
  token::CStr => LitKind::CStr,
  token::CStrRaw(n) => LitKind::CStrRaw(n),
- token::Err => LitKind::Err,
+ token::Err(_guar) => {
+ // This is the only place a `pm::bridge::LitKind::ErrWithGuar`
+ // is constructed. Note that an `ErrorGuaranteed` is available,
+ // as required. See the comment in `to_internal`.
+ LitKind::ErrWithGuar
+ }
  token::Bool => unreachable!(),
  }
  }
@@ -82,7 +87,16 @@ impl ToInternal<token::LitKind> for LitKind {
  LitKind::ByteStrRaw(n) => token::ByteStrRaw(n),
  LitKind::CStr => token::CStr,
  LitKind::CStrRaw(n) => token::CStrRaw(n),
- LitKind::Err => token::Err,
+ LitKind::ErrWithGuar => {
+ // This is annoying but valid. `LitKind::ErrWithGuar` would
+ // have an `ErrorGuaranteed` except that type isn't available
+ // in that crate. So we have to fake one. And we don't want to
+ // use a delayed bug because there might be lots of these,
+ // which would be expensive.
+ #[allow(deprecated)]
+ let guar = ErrorGuaranteed::unchecked_error_guaranteed();
+ token::Err(guar)
+ }
  }
  }
 }
@@ -477,7 +491,7 @@ impl server::FreeFunctions for Rustc<'_, '_> {
  | token::LitKind::ByteStrRaw(_)
  | token::LitKind::CStr
  | token::LitKind::CStrRaw(_)
- | token::LitKind::Err => return Err(()),
+ | token::LitKind::Err(_) => return Err(()),
  token::LitKind::Integer | token::LitKind::Float => {}
  }
 

compiler/rustc_hir_analysis/src/lib.rs

@@ -178,8 +178,9 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
  let _ = tcx.ensure().coherent_trait(trait_def_id);
  }
  // these queries are executed for side-effects (error reporting):
- res.and(tcx.ensure().crate_inherent_impls(()))
- .and(tcx.ensure().crate_inherent_impls_overlap_check(()))
+ let _ = tcx.ensure().crate_inherent_impls(());
+ let _ = tcx.ensure().crate_inherent_impls_overlap_check(());
+ res
  })?;
 
  if tcx.features().rustc_attrs {

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -1319,7 +1319,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  tcx.type_of(tcx.require_lang_item(hir::LangItem::CStr, Some(lit.span)))
  .skip_binder(),
  ),
- ast::LitKind::Err => Ty::new_misc_error(tcx),
+ ast::LitKind::Err(guar) => Ty::new_error(tcx, guar),
  }
  }
 

compiler/rustc_lint/src/reference_casting.rs

@@ -207,6 +207,13 @@ fn is_cast_to_bigger_memory_layout<'tcx>(
  }
 
  let from_layout = cx.layout_of(*inner_start_ty).ok()?;
+
+ // if the type isn't sized, we bail out, instead of potentially giving
+ // the user a meaningless warning.
+ if from_layout.is_unsized() {
+ return None;
+ }
+
  let alloc_layout = cx.layout_of(alloc_ty).ok()?;
  let to_layout = cx.layout_of(*inner_end_ty).ok()?;
 

compiler/rustc_mir_build/src/build/expr/as_constant.rs

@@ -164,11 +164,7 @@ fn lit_to_mir_constant<'tcx>(
  })?,
  (ast::LitKind::Bool(b), ty::Bool) => ConstValue::Scalar(Scalar::from_bool(*b)),
  (ast::LitKind::Char(c), ty::Char) => ConstValue::Scalar(Scalar::from_char(*c)),
- (ast::LitKind::Err, _) => {
- return Err(LitToConstError::Reported(
- tcx.dcx().delayed_bug("encountered LitKind::Err during mir build"),
- ));
- }
+ (ast::LitKind::Err(guar), _) => return Err(LitToConstError::Reported(*guar)),
  _ => return Err(LitToConstError::TypeError),
  };