Rollup of 5 pull requests

compiler/rustc_next_trait_solver/src/delegate.rs

@@ -1,3 +1,4 @@
+use std::fmt::Debug;
 use std::ops::Deref;
 
 use rustc_type_ir::solve::{
@@ -36,11 +37,17 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
     // FIXME: Uplift the leak check into this crate.
     fn leak_check(&self, max_input_universe: ty::UniverseIndex) -> Result<(), NoSolution>;
 
-    fn evaluate_const(
+    /// Evaluate a const, normalizing the type of the resulting value with `normalize_ty`.
+    /// Returns `Ok(None)` if the const is too generic, and `Err(_)` only if `normalize_ty`
+    /// failed.
+    fn evaluate_const<E: Debug>(
         &self,
         param_env: <Self::Interner as Interner>::ParamEnv,
         alias_const: ty::AliasConst<Self::Interner>,
-    ) -> Option<<Self::Interner as Interner>::Const>;
+        normalize_ty: impl FnOnce(
+            ty::Unnormalized<Self::Interner, <Self::Interner as Interner>::Ty>,
+        ) -> Result<<Self::Interner as Interner>::Ty, E>,
+    ) -> Result<Option<<Self::Interner as Interner>::Const>, E>;
 
     // FIXME: This only is here because `wf::obligations` is in `rustc_trait_selection`!
     fn well_formed_goals(

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

@@ -1403,19 +1403,21 @@ where
         Ok(())
     }
 
-    // Try to evaluate a const, or return `None` if the const is too generic.
-    // This doesn't mean the const isn't evaluatable, though, and should be treated
-    // as an ambiguity rather than no-solution.
+    // Try to evaluate a const and normalize the type of the resulting value, or return `None` if
+    // the const is too generic. This doesn't mean the const isn't evaluatable, though, and should
+    // be treated as an ambiguity rather than no-solution.
     pub(super) fn evaluate_const(
         &mut self,
         param_env: I::ParamEnv,
         alias_const: ty::AliasConst<I>,
-    ) -> Result<Option<I::Const>, RerunNonErased> {
+    ) -> Result<Option<I::Const>, NoSolutionOrRerunNonErased> {
         if self.typing_mode().is_erased_not_coherence() {
             match self.opaque_accesses.rerun_always(RerunReason::EvaluateConst)? {}
         }
 
-        Ok(self.delegate.evaluate_const(param_env, alias_const))
+        self.delegate.evaluate_const(param_env, alias_const, |ty| {
+            self.normalize(GoalSource::Misc, param_env, ty)
+        })
     }
 
     pub(super) fn evaluate_const_and_instantiate_projection_term(

compiler/rustc_session/src/options.rs

@@ -90,12 +90,16 @@ pub mod mitigation_coverage;
 
 mod target_modifier_consistency_check {
     use super::*;
-    pub(super) fn sanitizer(l: &TargetModifier, r: Option<&TargetModifier>) -> bool {
-        let mut lparsed: SanitizerSet = Default::default();
+    pub(super) fn sanitizer(
+        sess: &Session,
+        l: &TargetModifier,
+        r: Option<&TargetModifier>,
+    ) -> bool {
+        let mut lparsed: SanitizerSet = sess.target.options.default_sanitizers;
         let lval = if l.value_name.is_empty() { None } else { Some(l.value_name.as_str()) };
         parse::parse_sanitizers(&mut lparsed, lval);
 
-        let mut rparsed: SanitizerSet = Default::default();
+        let mut rparsed: SanitizerSet = sess.target.options.default_sanitizers;
         let rval = r.filter(|v| !v.value_name.is_empty()).map(|v| v.value_name.as_str());
         parse::parse_sanitizers(&mut rparsed, rval);
 
@@ -166,7 +170,7 @@ impl TargetModifier {
         match self.opt {
             OptionsTargetModifiers::UnstableOptions(unstable) => match unstable {
                 UnstableOptionsTargetModifiers::Sanitizer => {
-                    return target_modifier_consistency_check::sanitizer(self, other);
+                    return target_modifier_consistency_check::sanitizer(sess, self, other);
                 }
                 UnstableOptionsTargetModifiers::SanitizerCfiNormalizeIntegers => {
                     return target_modifier_consistency_check::sanitizer_cfi_normalize_integers(

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -1,4 +1,5 @@
 use std::collections::hash_map::Entry;
+use std::fmt::Debug;
 use std::mem;
 use std::ops::Deref;
 
@@ -319,19 +320,23 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         self.0.leak_check(max_input_universe, None).map_err(|_| NoSolution)
     }
 
-    fn evaluate_const(
+    fn evaluate_const<E: Debug>(
         &self,
         param_env: ty::ParamEnv<'tcx>,
         alias_const: ty::AliasConst<'tcx>,
-    ) -> Option<ty::Const<'tcx>> {
+        normalize_ty: impl FnOnce(ty::Unnormalized<'tcx, Ty<'tcx>>) -> Result<Ty<'tcx>, E>,
+    ) -> Result<Option<ty::Const<'tcx>>, E> {
         let ct = ty::Const::new_alias(self.tcx, ty::IsRigid::No, alias_const);
 
-        match crate::traits::try_evaluate_const(&self.0, ct, param_env) {
-            Ok(ct) => Some(ct),
-            Err(EvaluateConstErr::EvaluationFailure(e)) => Some(ty::Const::new_error(self.tcx, e)),
+        match crate::traits::try_evaluate_const(&self.0, ct, param_env, normalize_ty) {
+            Ok(ct) => Ok(Some(ct)),
+            Err(EvaluateConstErr::EvaluationFailure(e)) => {
+                Ok(Some(ty::Const::new_error(self.tcx, e)))
+            }
             Err(
                 EvaluateConstErr::InvalidConstParamTy(_) | EvaluateConstErr::HasGenericsOrInfers,
-            ) => None,
+            ) => Ok(None),
+            Err(EvaluateConstErr::FailedNormalization(e)) => Err(e),
         }
     }
 

compiler/rustc_trait_selection/src/traits/auto_trait.rs

@@ -853,8 +853,12 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 ty::PredicateKind::ConstEquate(c1, c2) => {
                     let evaluate = |c: ty::Const<'tcx>| {
                         if let ty::ConstKind::Alias(_, alias_const) = c.kind() {
-                            let ct =
-                                super::try_evaluate_const(selcx.infcx, c, obligation.param_env);
+                            let ct = super::try_evaluate_const(
+                                selcx.infcx,
+                                c,
+                                obligation.param_env,
+                                |ty| Ok::<_, !>(ty.skip_norm_wip()),
+                            );
 
                             if let Err(EvaluateConstErr::InvalidConstParamTy(_)) = ct {
                                 let span = alias_const.kind.def_span(self.tcx);

compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

@@ -67,7 +67,9 @@ pub fn is_const_evaluatable<'tcx>(
                 tcx.dcx().span_bug(span, "evaluating `ConstKind::Expr` is not currently supported");
             }
             ty::ConstKind::Alias(_, _) => {
-                match crate::traits::try_evaluate_const(infcx, unexpanded_ct, param_env) {
+                match crate::traits::try_evaluate_const(infcx, unexpanded_ct, param_env, |ty| {
+                    Ok::<_, !>(ty.skip_norm_wip())
+                }) {
                     Err(EvaluateConstErr::HasGenericsOrInfers) => {
                         Err(NotConstEvaluatable::Error(infcx.dcx().span_delayed_bug(
                             span,
@@ -98,7 +100,9 @@ pub fn is_const_evaluatable<'tcx>(
             _ => bug!("unexpected constkind in `is_const_evalautable: {unexpanded_ct:?}`"),
         };
 
-        match crate::traits::try_evaluate_const(infcx, unexpanded_ct, param_env) {
+        match crate::traits::try_evaluate_const(infcx, unexpanded_ct, param_env, |ty| {
+            Ok::<_, !>(ty.skip_norm_wip())
+        }) {
             // If we're evaluating a generic foreign constant, under a nightly compiler while
             // the current crate does not enable `feature(generic_const_exprs)`, abort
             // compilation with a useful error.

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -764,6 +764,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                                 self.selcx.infcx,
                                 c,
                                 obligation.param_env,
+                                |ty| Ok::<_, !>(ty.skip_norm_wip()),
                             ) {
                                 Ok(val) => Ok(val),
                                 e @ Err(EvaluateConstErr::HasGenericsOrInfers) => {

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -573,7 +573,7 @@ pub fn normalize_param_env_or_error<'tcx>(
 }
 
 #[derive(Debug)]
-pub enum EvaluateConstErr {
+pub enum EvaluateConstErr<E> {
     /// The constant being evaluated was either a generic parameter or inference variable, *or*,
     /// some alias const with either generic parameters or inference variables in its
     /// generic arguments.
@@ -585,6 +585,7 @@ pub enum EvaluateConstErr {
     /// CTFE failed to evaluate the constant in some unrecoverable way (e.g. encountered a `panic!`).
     /// This is also used when the constant was already tainted by error.
     EvaluationFailure(ErrorGuaranteed),
+    FailedNormalization(E),
 }
 
 // FIXME(BoxyUwU): Private this once we `generic_const_exprs` isn't doing its own normalization routine
@@ -601,7 +602,7 @@ pub fn evaluate_const<'tcx>(
     ct: ty::Const<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
 ) -> ty::Const<'tcx> {
-    match try_evaluate_const(infcx, ct, param_env) {
+    match try_evaluate_const(infcx, ct, param_env, |v| Ok::<_, !>(v.skip_norm_wip())) {
         Ok(ct) => ct,
         Err(EvaluateConstErr::EvaluationFailure(e) | EvaluateConstErr::InvalidConstParamTy(e)) => {
             ty::Const::new_error(infcx.tcx, e)
@@ -618,12 +619,13 @@ pub fn evaluate_const<'tcx>(
 ///
 /// You should not call this function unless you are implementing normalization itself. Prefer to use
 /// `normalize_erasing_regions` or the `normalize` functions on `ObligationCtxt`/`FnCtxt`/`InferCtxt`.
-#[instrument(level = "debug", skip(infcx), ret)]
-pub fn try_evaluate_const<'tcx>(
+#[instrument(level = "debug", skip(infcx, normalize_ty), ret)]
+pub fn try_evaluate_const<'tcx, E: Debug>(
     infcx: &InferCtxt<'tcx>,
     ct: ty::Const<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
-) -> Result<ty::Const<'tcx>, EvaluateConstErr> {
+    normalize_ty: impl FnOnce(Unnormalized<'tcx, Ty<'tcx>>) -> Result<Ty<'tcx>, E>,
+) -> Result<ty::Const<'tcx>, EvaluateConstErr<E>> {
     let tcx = infcx.tcx;
     let ct = infcx.resolve_vars_if_possible(ct);
     debug!(?ct);
@@ -762,7 +764,9 @@ pub fn try_evaluate_const<'tcx>(
             let span = alias_const.kind.def_span(tcx);
             match tcx.const_eval_resolve_for_typeck(typing_env, erased_alias_const, span) {
                 Ok(Ok(val)) => {
-                    Ok(ty::Const::new_value(tcx, val, alias_const.type_of(tcx).skip_norm_wip()))
+                    let ty = normalize_ty(alias_const.type_of(tcx))
+                        .map_err(EvaluateConstErr::FailedNormalization)?;
+                    Ok(ty::Const::new_value(tcx, val, ty))
                 }
                 Ok(Err(_)) => {
                     let e = tcx.dcx().delayed_bug(

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -921,11 +921,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
                 let evaluate = |c: ty::Const<'tcx>| {
                     if let ty::ConstKind::Alias(_, _) = c.kind() {
-                        match crate::traits::try_evaluate_const(self.infcx, c, obligation.param_env)
-                        {
-                            Ok(val) => Ok(val),
-                            Err(e) => Err(e),
-                        }
+                        crate::traits::try_evaluate_const(
+                            self.infcx,
+                            c,
+                            obligation.param_env,
+                            |v| Ok::<_, !>(v.skip_norm_wip()),
+                        )
                     } else {
                         Ok(c)
                     }

src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh

@@ -19,16 +19,4 @@ if [ "${DIST_TRY_BUILD:-0}" == "0" ]; then
     CC=/rustroot/bin/cc CXX=/rustroot/bin/c++ python3 ../x.py dist \
       gcc-dev \
       gcc
-    # We confirm that the built GCC has support for the `retain` attribute.
-    # FIXME: Maybe get the path from `.x.py` instead?
-    gcc_path="./build/$HOSTS/gcc/$HOSTS/install/bin/gcc"
-    c_code='int x __attribute__((used, retain));'
-    if echo "$c_code" | "$gcc_path" -S -x c -o - - | grep -i '"a.*R"'; then
-        echo "retain attribute is supported"
-    else
-        echo "retain attribute is not supported"
-        # We display the generated asm just in case...
-        echo "$c_code" | "$gcc_path" -S -x c -o - -
-        exit 1
-    fi
 fi

src/ci/docker/scripts/build-gcc.sh

@@ -4,27 +4,6 @@ set -eux
 
 source shared.sh
 
-# We have to build our own binutils for the GCC build, because the default CentOS 7 binutils are
-# too old, and they do not support `SHF_GNU_RETAIN`.
-BINUTILS="2.47"
-curl https://ci-mirrors.rust-lang.org/rustc/gcc/binutils-$BINUTILS.tar.xz | xzcat | tar xf -
-mkdir binutils-build
-cd binutils-build
-hide_output ../binutils-$BINUTILS/configure --prefix=/rustroot
-hide_output make -j$(nproc)
-hide_output make install
-
-cd ..
-rm -rf binutils-build binutils-$BINUTILS
-
-if echo '.section .test,"awR",@progbits' | as - -o /dev/null 2>/dev/null; then
-    echo "binutils assembler supports SHF_GNU_RETAIN"
-else
-    echo "binutils assembler DOES NOT support SHF_GNU_RETAIN"
-    exit 1
-fi
-
-
 # Note: in the future when bumping to version 10.1.0, also take care of the sed block below.
 # This version is specified in the Dockerfile
 GCC=$GCC_VERSION
@@ -57,7 +36,6 @@ sed -i'' 's|ftp://gcc\.gnu\.org/pub/gcc/infrastructure|https://ci-mirrors.rust-l
 mkdir ../gcc-build
 cd ../gcc-build
 
-export PATH=/rustroot/bin:$PATH
 # '-fno-reorder-blocks-and-partition' is required to
 # enable BOLT optimization of the C++ standard library,
 # which is included in librustc_driver.so

src/doc/rustc-dev-guide/.github/workflows/ci.yml

@@ -6,7 +6,7 @@ on:
       - main
   pull_request:
   schedule:
-    # Run multiple times a day as the successfull cached links are not checked every time.
+    # Run multiple times a day as the successful cached links are not checked every time.
     - cron: "0 */8 * * *"
 
 jobs:
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     env:
       MDBOOK_VERSION: 0.5.2
-      MDBOOK_LINKCHECK2_VERSION: 0.11.0
+      MDBOOK_LINKCHECK2_VERSION: 0.13.0
       MDBOOK_MERMAID_VERSION: 0.17.0
       MDBOOK_OUTPUT__LINKCHECK__FOLLOW_WEB_LINKS: ${{ github.event_name != 'pull_request' }}
       DEPLOY_DIR: book/html

src/doc/rustc-dev-guide/book.toml

@@ -26,6 +26,7 @@ level = 0
 
 [output.linkcheck]
 command = "ci/linkcheck.sh"
+require-md-extension = true
 follow-web-links = true
 exclude = [
     "crates\\.io",
@@ -57,6 +58,7 @@ cache-timeout = 90000
 warning-policy = "error"
 
 [output.html.redirect]
+"/backend/inline-asm.html" = "/asm.html"
 "/borrow_check.html" = "borrow-check.html"
 "/borrow_check/drop_check.html" = "/borrow-check/drop-check.html"
 "/borrow_check/moves_and_initialization.html" = "/borrow-check/moves-and-initialization.html"
@@ -77,6 +79,7 @@ warning-policy = "error"
 "/early_late_parameters.html" = "early-late-parameters.html"
 "/generic_parameters_summary.html" = "generic-parameters-summary.html"
 "/implementing_new_features.html" = "implementing-new-features.html"
+"/llm-guidance/index.html" = "/llm-guidance.html"
 "/miri.html" = "const-eval/interpret.html"
 "/profiling/with_perf.html" = "with-perf.html"
 "/profiling/with_rustc_perf.html" = "with-rustc-perf.html"

src/doc/rustc-dev-guide/rust-version

@@ -1 +1 @@
-e64c8a664d9da54fc239cd4404cbf67f0d624326
+2c39ff499469be916d4e45506d1afed69bbaddb7

src/doc/rustc-dev-guide/src/SUMMARY.md

@@ -32,11 +32,12 @@
         - [Fuchsia](./tests/ecosystem-test-jobs/fuchsia.md)
         - [Rust for Linux](./tests/ecosystem-test-jobs/rust-for-linux.md)
     - [Codegen backend testing](./tests/codegen-backend-tests/intro.md)
-        - [Cranelift codegen backend](./tests/codegen-backend-tests/cg_clif.md)
+        - [Cranelift codegen backend (stub)](./tests/codegen-backend-tests/cg_clif.md)
         - [GCC codegen backend](./tests/codegen-backend-tests/cg_gcc.md)
     - [Performance testing](./tests/perf.md)
     - [Autodiff CI job](./tests/autodiff-ci-job.md)
     - [Pre-stabilization CI job for the next solver and polonius alpha](./tests/x86_64-gnu-next-trait-solver-polonius-ci-job.md)
+    - [Parallel frontend CI job](./tests/optional-x86_64-gnu-parallel-frontend.md)
     - [Standard library semver breakage test](./tests/stdlib-semver-check.md)
     - [Misc info](./tests/misc.md)
 - [Debugging the compiler](./compiler-debugging.md)
@@ -108,7 +109,7 @@
 - [Rustdoc internals](./rustdoc-internals.md)
     - [Search](./rustdoc-internals/search.md)
     - [The `rustdoc-html` test suite](./rustdoc-internals/rustdoc-html-test-suite.md)
-    - [The `rustdoc-gui` test suite](./rustdoc-internals/rustdoc-gui-test-suite.md)
+    - [The `rustdoc-gui` test suite (stub)](./rustdoc-internals/rustdoc-gui-test-suite.md)
     - [The `rustdoc-json` test suite](./rustdoc-internals/rustdoc-json-test-suite.md)
 - [GPU offload internals](./offload/internals.md)
     - [Installation](./offload/installation.md)
@@ -225,8 +226,9 @@
         - [Member constraints](./borrow-check/region-inference/member-constraints.md)
         - [Placeholders and universes](./borrow-check/region-inference/placeholders-and-universes.md)
         - [Closure constraints](./borrow-check/region-inference/closure-constraints.md)
-        - [Error reporting](./borrow-check/region-inference/error-reporting.md)
+        - [Error reporting (stub)](./borrow-check/region-inference/error-reporting.md)
     - [Two-phase-borrows](./borrow-check/two-phase-borrows.md)
+    - [Debugging the borrow checker](./borrow-check/debugging.md)
 - [Closure capture inference](./closure.md)
 - [Async closures/"coroutine-closures"](coroutine-closures.md)
 
@@ -249,12 +251,12 @@
     - [LLVM codegen](./debuginfo/llvm-codegen.md)
     - [Debugger internals](./debuginfo/debugger-internals.md)
         - [LLDB internals](./debuginfo/lldb-internals.md)
-        - [GDB internals](./debuginfo/gdb-internals.md)
+        - [GDB internals (stub)](./debuginfo/gdb-internals.md)
     - [Debugger visualizers](./debuginfo/debugger-visualizers.md)
         - [LLDB - Python Providers](./debuginfo/lldb-visualizers.md)
         - [GDB - Python Providers](./debuginfo/gdb-visualizers.md)
-        - [CDB - Natvis](./debuginfo/natvis-visualizers.md)
-    - [Testing](./debuginfo/testing.md)
+        - [CDB - Natvis (stub)](./debuginfo/natvis-visualizers.md)
+    - [Testing (stub)](./debuginfo/testing.md)
     - [(Lecture notes) Debugging support in the Rust compiler](./debugging-support-in-rustc.md)
 - [Libraries and metadata](./backend/libs-and-metadata.md)
 - [Profile-guided optimization](./profile-guided-optimization.md)

src/doc/rustc-dev-guide/src/about-this-guide.md

@@ -31,7 +31,7 @@ There are several parts to this guide:
 1. [Appendices][p9] at the end with useful reference information.
    There are a few of these with different information, including a glossary.
 
-[p1]: ./building/how-to-build-and-run.html
+[p1]: ./building/how-to-build-and-run.md
 [p2]: ./contributing.md
 [p3]: ./building/bootstrapping/intro.md
 [p4]: ./part-2-intro.md

src/doc/rustc-dev-guide/src/appendix/background.md

@@ -264,7 +264,7 @@ don't actually do this in `rustc` though!):
 Check out the subtyping chapter from the
 [Rust Nomicon](https://doc.rust-lang.org/nomicon/subtyping.html).
 
-See the [variance](../variance.html) chapter of this guide for more info on how
+See the [variance](../variance.md) chapter of this guide for more info on how
 the type checker handles variance.
 
 <a id="free-vs-bound"></a>