Auto merge of rust-lang#115756 - oli-obk:early_const_prop_lint, r=<try>

WIP: move const prop lints before borrowck

r? `@ghost`

for this we need to stop revealing hidden types during const prop

and for that I'm opening this WIP PR to do some perf runs

Author: bors

.gitignore

@@ -52,6 +52,8 @@ build/
 /src/tools/x/target
 # Created by default with `src/ci/docker/run.sh`
 /obj/
+# Created on ICE during build
+rustc-ice-*.txt
 
 ## Temporary files
 *~

compiler/rustc_middle/src/query/mod.rs

@@ -1398,7 +1398,7 @@ rustc_queries! {
 
     /// Computes the layout of a type. Note that this implicitly
     /// executes in "reveal all" mode, and will normalize the input type.
-    query layout_of(
+    query layout_of_raw(
         key: ty::ParamEnvAnd<'tcx, Ty<'tcx>>
     ) -> Result<ty::layout::TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
         depth_limit

compiler/rustc_middle/src/ty/layout.rs

@@ -688,6 +688,39 @@ pub trait LayoutOf<'tcx>: LayoutOfHelpers<'tcx> {
     }
 }
 
+impl<'tcx> TyCtxt<'tcx> {
+    pub fn layout_of(
+        self,
+        query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
+    ) -> Result<TyAndLayout<'tcx>, &'tcx LayoutError<'tcx>> {
+        self.at(DUMMY_SP).layout_of(query)
+    }
+}
+
+impl<'tcx> TyCtxtAt<'tcx> {
+    pub fn layout_of(
+        self,
+        query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
+    ) -> Result<TyAndLayout<'tcx>, &'tcx LayoutError<'tcx>> {
+        let (param_env, ty) = query.into_parts();
+        let param_env = param_env.with_reveal_all_normalized(self.tcx);
+
+        // FIXME: We might want to have two different versions of `layout_of`:
+        // One that can be called after typecheck has completed and can use
+        // `normalize_erasing_regions` here and another one that can be called
+        // before typecheck has completed and uses `try_normalize_erasing_regions`.
+        let ty = match self.try_normalize_erasing_regions(param_env, ty) {
+            Ok(t) => t,
+            Err(normalization_error) => {
+                return Err(self
+                    .arena
+                    .alloc(LayoutError::NormalizationFailure(ty, normalization_error)));
+            }
+        };
+        self.layout_of_raw(param_env.and(ty))
+    }
+}
+
 impl<'tcx, C: LayoutOfHelpers<'tcx>> LayoutOf<'tcx> for C {}
 
 impl<'tcx> LayoutOfHelpers<'tcx> for LayoutCx<'tcx, TyCtxt<'tcx>> {

compiler/rustc_query_system/src/query/job.rs

@@ -174,7 +174,7 @@ impl QueryJobId {
         while let Some(id) = current_id {
             let info = query_map.get(&id).unwrap();
             // FIXME: This string comparison should probably not be done.
-            if format!("{:?}", info.query.dep_kind) == "layout_of" {
+            if format!("{:?}", info.query.dep_kind) == "layout_of_raw" {
                 depth += 1;
                 last_layout = Some((info.clone(), depth));
             }

compiler/rustc_ty_utils/src/layout.rs

@@ -25,38 +25,17 @@ use crate::errors::{
 use crate::layout_sanity_check::sanity_check_layout;
 
 pub fn provide(providers: &mut Providers) {
-    *providers = Providers { layout_of, ..*providers };
+    *providers = Providers { layout_of_raw, ..*providers };
 }
 
 #[instrument(skip(tcx, query), level = "debug")]
-fn layout_of<'tcx>(
+fn layout_of_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
     query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
 ) -> Result<TyAndLayout<'tcx>, &'tcx LayoutError<'tcx>> {
     let (param_env, ty) = query.into_parts();
     debug!(?ty);
 
-    let param_env = param_env.with_reveal_all_normalized(tcx);
-    let unnormalized_ty = ty;
-
-    // FIXME: We might want to have two different versions of `layout_of`:
-    // One that can be called after typecheck has completed and can use
-    // `normalize_erasing_regions` here and another one that can be called
-    // before typecheck has completed and uses `try_normalize_erasing_regions`.
-    let ty = match tcx.try_normalize_erasing_regions(param_env, ty) {
-        Ok(t) => t,
-        Err(normalization_error) => {
-            return Err(tcx
-                .arena
-                .alloc(LayoutError::NormalizationFailure(ty, normalization_error)));
-        }
-    };
-
-    if ty != unnormalized_ty {
-        // Ensure this layout is also cached for the normalized type.
-        return tcx.layout_of(param_env.and(ty));
-    }
-
     let cx = LayoutCx { tcx, param_env };
 
     let layout = layout_of_uncached(&cx, ty)?;

src/etc/rust_analyzer_settings.json

@@ -16,7 +16,7 @@
         "compiler/rustc_codegen_gcc/Cargo.toml"
     ],
     "rust-analyzer.rustfmt.overrideCommand": [
-        "./build/host/rustfmt/bin/rustfmt",
+        "${workspaceFolder}/build/host/rustfmt/bin/rustfmt",
         "--edition=2021"
     ],
     "rust-analyzer.procMacro.server": "./build/host/stage0/libexec/rust-analyzer-proc-macro-srv",

tests/ui/consts/const-size_of-cycle.stderr

@@ -15,7 +15,6 @@ note: ...which requires const-evaluating + checking `Foo::bytes::{constant#0}`..
 LL |     bytes: [u8; std::mem::size_of::<Foo>()]
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: ...which requires computing layout of `Foo`...
-   = note: ...which requires computing layout of `[u8; std::mem::size_of::<Foo>()]`...
    = note: ...which requires normalizing `[u8; std::mem::size_of::<Foo>()]`...
    = note: ...which again requires evaluating type-level constant, completing the cycle
 note: cycle used when checking that `Foo` is well-formed

tests/ui/consts/issue-44415.stderr

@@ -15,7 +15,6 @@ note: ...which requires const-evaluating + checking `Foo::bytes::{constant#0}`..
 LL |     bytes: [u8; unsafe { intrinsics::size_of::<Foo>() }],
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: ...which requires computing layout of `Foo`...
-   = note: ...which requires computing layout of `[u8; unsafe { intrinsics::size_of::<Foo>() }]`...
    = note: ...which requires normalizing `[u8; unsafe { intrinsics::size_of::<Foo>() }]`...
    = note: ...which again requires evaluating type-level constant, completing the cycle
 note: cycle used when checking that `Foo` is well-formed

tests/ui/layout/layout-cycle.stderr

@@ -1,7 +1,6 @@
 error[E0391]: cycle detected when computing layout of `S<S<()>>`
    |
-   = note: ...which requires computing layout of `<S<()> as Tr>::I`...
-   = note: ...which again requires computing layout of `S<S<()>>`, completing the cycle
+   = note: ...which immediately requires computing layout of `S<S<()>>` again
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
 error: failed to get layout for S<S<()>>: a cycle occurred during layout computation

tests/ui/layout/valid_range_oob.stderr

@@ -2,6 +2,6 @@
 error: the compiler unexpectedly panicked. this is a bug.
 
 query stack during panic:
-#0 [layout_of] computing layout of `Foo`
+#0 [layout_of_raw] computing layout of `Foo`
 #1 [eval_to_allocation_raw] const-evaluating + checking `FOO`
 end of query stack