Rollup of 24 pull requests

Cargo.lock

@@ -561,9 +561,9 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
 [[package]]
 name = "chacha20"
@@ -1400,10 +1400,11 @@ dependencies = [
 
 [[package]]
 name = "eyre"
-version = "0.6.12"
+version = "0.6.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
+checksum = "c08309dbcc659c5549a24ddb9b27027640641b282ef5768267c7e675558986a3"
 dependencies = [
+ "autocfg",
  "indenter",
  "once_cell",
 ]

compiler/rustc_builtin_macros/src/diagnostics.rs

@@ -562,23 +562,23 @@ pub(crate) enum EnvNotDefined {
     CargoEnvVar {
         #[primary_span]
         span: Span,
-        var: Symbol,
+        var: String,
         var_expr: String,
     },
     #[diag("environment variable `{$var}` not defined at compile time")]
     #[help("there is a similar Cargo environment variable: `{$suggested_var}`")]
     CargoEnvVarTypo {
         #[primary_span]
         span: Span,
-        var: Symbol,
+        var: String,
         suggested_var: Symbol,
     },
     #[diag("environment variable `{$var}` not defined at compile time")]
     #[help("use `std::env::var({$var_expr})` to read the variable at run time")]
     CustomEnvVar {
         #[primary_span]
         span: Span,
-        var: Symbol,
+        var: String,
         var_expr: String,
     },
 }
@@ -588,7 +588,7 @@ pub(crate) enum EnvNotDefined {
 pub(crate) struct EnvNotUnicode {
     #[primary_span]
     pub(crate) span: Span,
-    pub(crate) var: Symbol,
+    pub(crate) var: String,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_builtin_macros/src/env.rs

@@ -6,9 +6,8 @@
 use std::env;
 use std::env::VarError;
 
-use rustc_ast::token::{self, LitKind};
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{ExprKind, GenericArg, Mutability};
+use rustc_ast::{GenericArg, Mutability};
 use rustc_ast_pretty::pprust;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_span::edit_distance::edit_distance;
@@ -69,14 +68,8 @@ pub(crate) fn expand_option_env<'cx>(
             ))
         }
         Err(VarError::NotUnicode(_)) => {
-            let ExprKind::Lit(token::Lit {
-                kind: LitKind::Str | LitKind::StrRaw(..), symbol, ..
-            }) = &var_expr.kind
-            else {
-                unreachable!("`expr_to_string` ensures this is a string lit")
-            };
-
-            let guar = cx.dcx().emit_err(diagnostics::EnvNotUnicode { span: sp, var: *symbol });
+            let escaped_var = var.as_str().escape_debug().to_string();
+            let guar = cx.dcx().emit_err(diagnostics::EnvNotUnicode { span: sp, var: escaped_var });
             return ExpandResult::Ready(DummyResult::any(sp, guar));
         }
         Ok(value) => cx.expr_call_global(
@@ -106,6 +99,7 @@ pub(crate) fn expand_env<'cx>(
     };
 
     let var_expr = exprs.next().unwrap();
+    // FIXME: `get_exprs_from_tts()` already performed macro expansion...
     let ExpandResult::Ready(mac) = expr_to_string(cx, var_expr.clone(), "expected string literal")
     else {
         return ExpandResult::Retry(());
@@ -133,49 +127,37 @@ pub(crate) fn expand_env<'cx>(
     let value = lookup_env(cx, var);
     cx.sess.env_depinfo.borrow_mut().insert((var, value.as_ref().ok().copied()));
     let e = match value {
-        Err(err) => {
-            let ExprKind::Lit(token::Lit {
-                kind: LitKind::Str | LitKind::StrRaw(..), symbol, ..
-            }) = &var_expr.kind
-            else {
-                unreachable!("`expr_to_string` ensures this is a string lit")
-            };
-
-            let var = var.as_str();
-            let guar = match err {
-                VarError::NotPresent => {
-                    if let Some(msg_from_user) = custom_msg {
-                        cx.dcx().emit_err(diagnostics::EnvNotDefinedWithUserMessage {
-                            span,
-                            msg_from_user,
-                        })
-                    } else if let Some(suggested_var) = find_similar_cargo_var(var)
-                        && suggested_var != var
-                    {
-                        cx.dcx().emit_err(diagnostics::EnvNotDefined::CargoEnvVarTypo {
-                            span,
-                            var: *symbol,
-                            suggested_var: Symbol::intern(suggested_var),
-                        })
-                    } else if is_cargo_env_var(var) {
-                        cx.dcx().emit_err(diagnostics::EnvNotDefined::CargoEnvVar {
-                            span,
-                            var: *symbol,
-                            var_expr: pprust::expr_to_string(&var_expr),
-                        })
-                    } else {
-                        cx.dcx().emit_err(diagnostics::EnvNotDefined::CustomEnvVar {
-                            span,
-                            var: *symbol,
-                            var_expr: pprust::expr_to_string(&var_expr),
-                        })
-                    }
-                }
-                VarError::NotUnicode(_) => {
-                    cx.dcx().emit_err(diagnostics::EnvNotUnicode { span, var: *symbol })
-                }
+        Err(VarError::NotPresent) => {
+            let var_str = var.as_str();
+            let escaped_var = var_str.escape_debug().to_string();
+            let guar = if let Some(msg_from_user) = custom_msg {
+                cx.dcx().emit_err(diagnostics::EnvNotDefinedWithUserMessage { span, msg_from_user })
+            } else if let Some(suggested_var) = find_similar_cargo_var(var_str)
+                && suggested_var != var_str
+            {
+                cx.dcx().emit_err(diagnostics::EnvNotDefined::CargoEnvVarTypo {
+                    span,
+                    var: escaped_var,
+                    suggested_var: Symbol::intern(suggested_var),
+                })
+            } else if is_cargo_env_var(var_str) {
+                cx.dcx().emit_err(diagnostics::EnvNotDefined::CargoEnvVar {
+                    span,
+                    var: escaped_var,
+                    var_expr: pprust::expr_to_string(&var_expr),
+                })
+            } else {
+                cx.dcx().emit_err(diagnostics::EnvNotDefined::CustomEnvVar {
+                    span,
+                    var: escaped_var,
+                    var_expr: pprust::expr_to_string(&var_expr),
+                })
             };
-
+            return ExpandResult::Ready(DummyResult::any(sp, guar));
+        }
+        Err(VarError::NotUnicode(_)) => {
+            let escaped_var = var.as_str().escape_debug().to_string();
+            let guar = cx.dcx().emit_err(diagnostics::EnvNotUnicode { span, var: escaped_var });
             return ExpandResult::Ready(DummyResult::any(sp, guar));
         }
         Ok(value) => cx.expr_str(span, value),

compiler/rustc_codegen_ssa/src/back/rpath.rs

@@ -70,8 +70,8 @@ fn get_rpath_relative_to_output(config: &RPathConfig<'_>, lib: &Path) -> OsStrin
     let output = config.out_filename.parent().unwrap();
 
     // If output or lib is empty, just assume it locates in current path
-    let lib = if lib == Path::new("") { Path::new(".") } else { lib };
-    let output = if output == Path::new("") { Path::new(".") } else { output };
+    let lib = if lib.is_empty() { Path::new(".") } else { lib };
+    let output = if output.is_empty() { Path::new(".") } else { output };
 
     let lib = try_canonicalize(lib).unwrap();
     let output = try_canonicalize(output).unwrap();

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -60,7 +60,7 @@ pub(crate) enum MinMax {
 
 /// Whether two types `T` and `U` are compatible when a value of type `T` is passed as a c-variadic
 /// argument and read as a value of type `U`.
-enum VarArgCompatible {
+pub enum VarArgCompatible {
     /// `T` and `U` are compatible, e.g.
     ///
     /// - They're the same type.
@@ -829,15 +829,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             return interp_ok(());
         }
 
-        // Types of different sizes can never be compatible.
-        if arg_mplace.layout.size != callee_type.size {
-            throw_ub_format!(
-                "va_arg type mismatch: requested `{}` is incompatible with next argument of type `{}`",
-                callee_ty,
-                caller_ty,
-            )
-        }
-
         match self.validate_c_variadic_compatible_ty(arg_mplace.layout.ty, callee_type.ty)? {
             VarArgCompatible::Compatible => interp_ok(()),
             VarArgCompatible::Incompatible => throw_ub_format!(
@@ -875,7 +866,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// - `T` and `U` are both pointers, and their target types are compatible.
     /// - `T` is a pointer to [`std::ffi::c_void`] and `U` is a pointer to [`i8`] or [`u8`],
     /// or vice versa.
-    fn validate_c_variadic_compatible_ty(
+    pub fn validate_c_variadic_compatible_ty(
         &mut self,
         caller_type: Ty<'tcx>,
         callee_type: Ty<'tcx>,

compiler/rustc_const_eval/src/interpret/mod.rs

@@ -29,6 +29,7 @@ pub use self::intern::{
     HasStaticRootDefId, InternError, InternKind, intern_const_alloc_for_constprop,
     intern_const_alloc_recursive,
 };
+pub use self::intrinsics::VarArgCompatible;
 pub use self::machine::{
     AllocMap, Machine, MayLeak, RetagMode, ReturnAction, compile_time_machine,
 };

compiler/rustc_hir_typeck/src/intrinsicck.rs

@@ -75,20 +75,15 @@ fn check_transmute<'tcx>(
     hir_id: HirId,
 ) -> Result<(), ErrorGuaranteed> {
     let span = tcx.hir_span(hir_id);
-    let normalize = |ty| {
-        if let Ok(ty) = tcx.try_normalize_erasing_regions(typing_env, ty) {
-            ty
-        } else {
-            Ty::new_error_with_message(
-                tcx,
-                span,
-                format!("tried to normalize non-wf type {ty:#?} in check_transmute"),
-            )
-        }
+    let normalize = |ty: Unnormalized<'tcx, Ty<'tcx>>| -> Result<Ty<'tcx>, ErrorGuaranteed> {
+        tcx.try_normalize_erasing_regions(typing_env, ty).map_err(|err| {
+            let err = LayoutError::NormalizationFailure(ty.skip_normalization(), err);
+            tcx.dcx().struct_span_err(span, err.to_string()).emit()
+        })
     };
 
-    let from = normalize(from);
-    let to = normalize(to);
+    let from = normalize(from)?;
+    let to = normalize(to)?;
     trace!(?from, ?to);
 
     // Transmutes that are only changing lifetimes are always ok.

compiler/rustc_metadata/src/creader.rs

@@ -86,12 +86,6 @@ pub struct CStore {
     has_crate_resolve_with_fail: bool,
 }
 
-impl std::fmt::Debug for CStore {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("CStore").finish_non_exhaustive()
-    }
-}
-
 pub enum LoadedMacro {
     MacroDef {
         def: MacroDef,
@@ -113,12 +107,10 @@ enum LoadResult {
     Loaded(Library),
 }
 
-struct CrateDump<'a>(&'a CStore);
-
-impl<'a> std::fmt::Debug for CrateDump<'a> {
+impl std::fmt::Debug for CStore {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(fmt, "resolved crates:")?;
-        for (cnum, data) in self.0.iter_crate_data() {
+        for (cnum, data) in self.iter_crate_data() {
             writeln!(fmt, "  name: {}", data.name())?;
             writeln!(fmt, "  cnum: {cnum}")?;
             writeln!(fmt, "  hash: {}", data.hash())?;
@@ -1288,7 +1280,7 @@ impl CStore {
         self.report_unused_deps_in_crate(tcx, krate);
         self.report_future_incompatible_deps(tcx, krate);
 
-        info!("{:?}", CrateDump(self));
+        info!("{:?}", self);
     }
 
     /// Process an `extern crate foo` AST node.

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -282,10 +282,7 @@ where
         goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
     ) -> bool {
         self.probe(|| {
-            EvalCtxt::enter_root(self, self.cx().recursion_limit(), I::Span::dummy(), |ecx| {
-                ecx.evaluate_goal(GoalSource::Misc, goal, None)
-            })
-            .is_ok_and(|r| match r.certainty {
+            self.evaluate_root_goal(goal, I::Span::dummy(), None).is_ok_and(|r| match r.certainty {
                 Certainty::Yes => true,
                 Certainty::Maybe(MaybeInfo {
                     cause: _,
@@ -359,12 +356,11 @@ fn maybe_evaluate_root_goal_with_higher_recursion_limit<D, I>(
             EvalCtxt::enter_root(delegate, delegate.cx().recursion_limit() * 2, span, |ecx| {
                 ecx.evaluate_goal_no_fast_paths(GoalSource::Misc, goal)
             });
-        if let Ok(goal_evaluation) = &rerun_result
-            && !goal_evaluation.certainty.is_overflow()
-        {
-            Ok(rerun_result)
-        } else {
+
+        if rerun_result.as_ref().is_ok_and(|evaluation| evaluation.certainty.is_overflow()) {
             Err(())
+        } else {
+            Ok(rerun_result)
         }
     });
     if let Ok(rerun_result) = rerun_result {
@@ -408,12 +404,11 @@ fn maybe_evaluate_root_goal_for_proof_tree_with_higher_recursion_limit<D, I>(
             span,
             delegate.cx().recursion_limit() * 2,
         );
-        if let Ok(response) = &new_goal_evaluation.result
-            && !response.value.certainty.is_overflow()
-        {
-            Ok((new_result, new_goal_evaluation))
-        } else {
+
+        if new_goal_evaluation.result.is_ok_and(|response| response.value.certainty.is_overflow()) {
             Err(())
+        } else {
+            Ok((new_result, new_goal_evaluation))
         }
     });
     if let Ok(rerun_result) = rerun_result {

compiler/rustc_parse/src/diagnostics.rs

@@ -1118,6 +1118,27 @@ pub(crate) struct ArrayBracketsInsteadOfBracesSugg {
     pub right: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("attributes are not allowed inside imports")]
+pub(crate) struct AttrInUseTree {
+    #[primary_span]
+    pub attr_span: Span,
+    #[subdiagnostic]
+    pub sub: Option<AttrInUseTreeSugg>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion("move the import to its own item", style = "verbose")]
+pub(crate) struct AttrInUseTreeSugg {
+    #[suggestion_part(code = "{code}")]
+    pub use_lo: Span,
+    #[suggestion_part(code = "")]
+    pub attr_span: Span,
+    #[suggestion_part(code = "")]
+    pub tree_span: Span,
+    pub code: String,
+}
+
 #[derive(Diagnostic)]
 #[diag("`match` arm body without braces")]
 pub(crate) struct MatchArmBodyWithoutBraces {

compiler/rustc_parse/src/parser/attr.rs

@@ -310,11 +310,15 @@ impl<'a> Parser<'a> {
     /// Parses an inner part of an attribute (the path and following tokens).
     /// The tokens must be either a delimited token stream, or empty token stream,
     /// or the "legacy" key-value form.
-    ///     PATH `(` TOKEN_STREAM `)`
-    ///     PATH `[` TOKEN_STREAM `]`
-    ///     PATH `{` TOKEN_STREAM `}`
-    ///     PATH
-    ///     PATH `=` UNSUFFIXED_LIT
+    ///
+    /// ```text
+    /// PATH `(` TOKEN_STREAM `)`
+    /// PATH `[` TOKEN_STREAM `]`
+    /// PATH `{` TOKEN_STREAM `}`
+    /// PATH
+    /// PATH `=` UNSUFFIXED_LIT
+    /// ```
+    ///
     /// The delimiters or `=` are still put into the resulting token stream.
     pub fn parse_attr_item(
         &mut self,