Auto merge of #148040 - saethlin:trivial-consts, r=<try>

rust-bors[bot] · web-flow · commit 4931b5e2c7ed · 2025-10-24T21:28:22.000Z
Add a fast path for lowering trivial consts
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -292,6 +292,9 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
+    if let Some((value, _ty)) = tcx.is_trivial_const(key.value.instance.def_id()) {
+        return Ok(value);
+    }
     tcx.eval_to_allocation_raw(key).map(|val| turn_into_const_value(tcx, val, key))
 }
 
@@ -356,6 +359,7 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
     typing_env: ty::TypingEnv<'tcx>,
 ) -> Result<R, ErrorHandled> {
     let def = cid.instance.def.def_id();
+
     let is_static = tcx.is_static(def);
 
     let mut ecx = InterpCx::new(
@@ -368,6 +372,18 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
         // so we have to reject reading mutable global memory.
         CompileTimeMachine::new(CanAccessMutGlobal::from(is_static), CheckAlignment::Error),
     );
+
+    if let Some((value, ty)) = tcx.is_trivial_const(def) {
+        let layout = ecx.layout_of(ty).unwrap();
+        let opty = ecx.const_val_to_op(value, ty, Some(layout)).unwrap();
+        let res = ecx.allocate(layout, MemoryKind::Stack).unwrap();
+        ecx.copy_op(&opty, &res).unwrap();
+
+        intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &res).unwrap();
+
+        return Ok(R::make_result(res, &mut ecx));
+    }
+
     let res = ecx.load_mir(cid.instance.def, cid.promoted);
     res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, body))
         .report_err()
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
@@ -1088,6 +1088,9 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
 
     sess.time("MIR_borrow_checking", || {
         tcx.par_hir_body_owners(|def_id| {
+            if tcx.is_trivial_const(def_id).is_some() {
+                return;
+            }
             if !tcx.is_typeck_child(def_id.to_def_id()) {
                 // Child unsafety and borrowck happens together with the parent
                 tcx.ensure_ok().check_unsafety(def_id);
@@ -1198,7 +1201,9 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) {
     if tcx.sess.opts.unstable_opts.validate_mir {
         sess.time("ensuring_final_MIR_is_computable", || {
             tcx.par_hir_body_owners(|def_id| {
-                tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
+                if tcx.is_trivial_const(def_id).is_none() {
+                    tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
+                }
             });
         });
     }
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -240,6 +240,7 @@ provide! { tcx, def_id, other, cdata,
     thir_abstract_const => { table }
     optimized_mir => { table }
     mir_for_ctfe => { table }
+    is_trivial_const => { table }
     closure_saved_names_of_captured_variables => { table }
     mir_coroutine_witnesses => { table }
     promoted_mir => { table }
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1791,8 +1791,15 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
                 }
             }
+            let mut is_trivial = false;
             if encode_const {
-                record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
+                if let Some((val, ty)) = tcx.is_trivial_const(def_id) {
+                    is_trivial = true;
+                    record!(self.tables.is_trivial_const[def_id.to_def_id()] <- (val, ty));
+                } else {
+                    is_trivial = false;
+                    record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
+                }
 
                 // FIXME(generic_const_exprs): this feels wrong to have in `encode_mir`
                 let abstract_const = tcx.thir_abstract_const(def_id);
@@ -1810,7 +1817,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     }
                 }
             }
-            record!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id));
+            if !is_trivial {
+                record!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id));
+            }
 
             if self.tcx.is_coroutine(def_id.to_def_id())
                 && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id)
@@ -2234,6 +2243,9 @@ fn prefetch_mir(tcx: TyCtxt<'_>) {
 
     let reachable_set = tcx.reachable_set(());
     par_for_each_in(tcx.mir_keys(()), |&&def_id| {
+        if tcx.is_trivial_const(def_id).is_some() {
+            return;
+        }
         let (encode_const, encode_opt) = should_encode_mir(tcx, reachable_set, def_id);
 
         if encode_const {
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -29,6 +29,7 @@ use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use rustc_middle::middle::lib_features::FeatureStability;
 use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
 use rustc_middle::mir;
+use rustc_middle::mir::ConstValue;
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
 use rustc_middle::util::Providers;
@@ -426,6 +427,7 @@ define_tables! {
     object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>,
     optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>,
     mir_for_ctfe: Table<DefIndex, LazyValue<mir::Body<'static>>>,
+    is_trivial_const: Table<DefIndex, LazyValue<(ConstValue, Ty<'static>)>>,
     closure_saved_names_of_captured_variables: Table<DefIndex, LazyValue<IndexVec<FieldIdx, Symbol>>>,
     mir_coroutine_witnesses: Table<DefIndex, LazyValue<mir::CoroutineLayout<'static>>>,
     promoted_mir: Table<DefIndex, LazyValue<IndexVec<mir::Promoted, mir::Body<'static>>>>,
diff --git a/compiler/rustc_metadata/src/rmeta/parameterized.rs b/compiler/rustc_metadata/src/rmeta/parameterized.rs
@@ -102,6 +102,7 @@ trivially_parameterized_over_tcx! {
     rustc_middle::middle::lib_features::FeatureStability,
     rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
     rustc_middle::mir::ConstQualifs,
+    rustc_middle::mir::ConstValue,
     rustc_middle::ty::AnonConstKind,
     rustc_middle::ty::AssocContainer,
     rustc_middle::ty::AsyncDestructor,
diff --git a/compiler/rustc_middle/src/mir/graphviz.rs b/compiler/rustc_middle/src/mir/graphviz.rs
@@ -16,6 +16,7 @@ where
 
     let mirs = def_ids
         .iter()
+        .filter(|def_id| tcx.is_trivial_const(*def_id).is_none())
         .flat_map(|def_id| {
             if tcx.is_const_fn(*def_id) {
                 vec![tcx.optimized_mir(*def_id), tcx.mir_for_ctfe(*def_id)]
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -353,8 +353,10 @@ pub fn write_mir_pretty<'tcx>(
             // are shared between mir_for_ctfe and optimized_mir
             writer.write_mir_fn(tcx.mir_for_ctfe(def_id), w)?;
         } else {
-            let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));
-            render_body(w, instance_mir)?;
+            if tcx.is_trivial_const(def_id).is_none() {
+                let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));
+                render_body(w, instance_mir)?;
+            }
         }
     }
     Ok(())
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
@@ -160,6 +160,14 @@ impl EraseType for Result<mir::ConstValue, mir::interpret::ErrorHandled> {
     type Result = [u8; size_of::<Result<mir::ConstValue, mir::interpret::ErrorHandled>>()];
 }
 
+impl EraseType for Option<mir::ConstValue> {
+    type Result = [u8; size_of::<Option<mir::ConstValue>>()];
+}
+
+impl EraseType for Option<(mir::ConstValue, Ty<'_>)> {
+    type Result = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
+}
+
 impl EraseType for EvalToValTreeResult<'_> {
     type Result = [u8; size_of::<EvalToValTreeResult<'static>>()];
 }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
@@ -2719,6 +2719,12 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    query is_trivial_const(def_id: DefId) -> Option<(mir::ConstValue, Ty<'tcx>)> {
+        desc { |tcx| "checking if `{}` is a trivial const", tcx.def_path_str(def_id) }
+        cache_on_disk_if { def_id.is_local() }
+        separate_provide_extern
+    }
+
     /// Checks for the nearest `#[sanitize(xyz = "off")]` or
     /// `#[sanitize(xyz = "on")]` on this def and any enclosing defs, up to the
     /// crate root.
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
@@ -23,11 +23,11 @@ use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::def_id::LocalDefId;
 use rustc_index::IndexVec;
 use rustc_middle::mir::{
-    AnalysisPhase, Body, CallSource, ClearCrossCrate, ConstOperand, ConstQualifs, LocalDecl,
-    MirPhase, Operand, Place, ProjectionElem, Promoted, RuntimePhase, Rvalue, START_BLOCK,
-    SourceInfo, Statement, StatementKind, TerminatorKind,
+    AnalysisPhase, Body, CallSource, ClearCrossCrate, ConstOperand, ConstQualifs, ConstValue,
+    LocalDecl, MirPhase, Operand, Place, ProjectionElem, Promoted, RuntimePhase, Rvalue,
+    START_BLOCK, SourceInfo, Statement, StatementKind, TerminatorKind,
 };
-use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::util::Providers;
 use rustc_middle::{bug, query, span_bug};
 use rustc_mir_build::builder::build_mir;
@@ -226,6 +226,12 @@ pub fn provide(providers: &mut Providers) {
         promoted_mir,
         deduced_param_attrs: deduce_param_attrs::deduced_param_attrs,
         coroutine_by_move_body_def_id: coroutine::coroutine_by_move_body_def_id,
+        is_trivial_const: |tcx, def| {
+            if tcx.def_kind(def) != DefKind::Const {
+                return None;
+            }
+            is_trivial_const(&tcx.mir_built(def).borrow())
+        },
         ..providers.queries
     };
 }
@@ -376,8 +382,48 @@ fn mir_const_qualif(tcx: TyCtxt<'_>, def: LocalDefId) -> ConstQualifs {
     validator.qualifs_in_return_place()
 }
 
+fn is_trivial_const<'tcx>(body: &Body<'tcx>) -> Option<(ConstValue, Ty<'tcx>)> {
+    use rustc_middle::mir::RETURN_PLACE;
+
+    if body.has_opaque_types() {
+        return None;
+    }
+
+    if body.basic_blocks.len() != 1 {
+        return None;
+    }
+
+    let block = &body.basic_blocks[START_BLOCK];
+    if block.statements.len() != 1 {
+        return None;
+    }
+
+    if block.terminator().kind != TerminatorKind::Return {
+        return None;
+    }
+
+    let StatementKind::Assign(box (place, rvalue)) = &block.statements[0].kind else {
+        return None;
+    };
+
+    if *place != Place::from(RETURN_PLACE) {
+        return None;
+    }
+
+    if let Rvalue::Use(Operand::Constant(c)) = rvalue {
+        if let rustc_middle::mir::Const::Val(v, ty) = c.const_ {
+            return Some((v, ty));
+        }
+    }
+
+    return None;
+}
+
 fn mir_built(tcx: TyCtxt<'_>, def: LocalDefId) -> &Steal<Body<'_>> {
     let mut body = build_mir(tcx, def);
+    if tcx.def_kind(def) == DefKind::Const && is_trivial_const(&body).is_some() {
+        return tcx.alloc_steal_mir(body);
+    }
 
     pass_manager::dump_mir_for_phase_change(tcx, &body);
 
@@ -409,6 +455,11 @@ fn mir_promoted(
     tcx: TyCtxt<'_>,
     def: LocalDefId,
 ) -> (&Steal<Body<'_>>, &Steal<IndexVec<Promoted, Body<'_>>>) {
+    debug_assert!(
+        tcx.is_trivial_const(def).is_none(),
+        "Tried to get mir_promoted of a trivial const"
+    );
+
     // Ensure that we compute the `mir_const_qualif` for constants at
     // this point, before we steal the mir-const result.
     // Also this means promotion can rely on all const checks having been done.
@@ -436,6 +487,9 @@ fn mir_promoted(
         tcx.ensure_done().coroutine_by_move_body_def_id(def);
     }
 
+    // the `is_trivial_const` query uses mir_built, so make sure it is run.
+    tcx.ensure_done().is_trivial_const(def);
+
     let mut body = tcx.mir_built(def).steal();
     if let Some(error_reported) = const_qualifs.tainted_by_errors {
         body.tainted_by_errors = Some(error_reported);
@@ -463,6 +517,10 @@ fn mir_promoted(
 
 /// Compute the MIR that is used during CTFE (and thus has no optimizations run on it)
 fn mir_for_ctfe(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &Body<'_> {
+    debug_assert!(
+        tcx.is_trivial_const(def_id).is_none(),
+        "Tried to get mir_for_ctfe of a trivial const"
+    );
     tcx.arena.alloc(inner_mir_for_ctfe(tcx, def_id))
 }
 
@@ -778,6 +836,7 @@ fn inner_optimized_mir(tcx: TyCtxt<'_>, did: LocalDefId) -> Body<'_> {
         Some(other) => panic!("do not use `optimized_mir` for constants: {other:?}"),
     }
     debug!("about to call mir_drops_elaborated...");
+
     let body = tcx.mir_drops_elaborated_and_const_checked(did).steal();
     let mut body = remap_mir_for_const_eval_select(tcx, body, hir::Constness::NotConst);
 

Original file line number	Diff line number	Diff line change
`@@ -353,8 +353,10 @@ pub fn write_mir_pretty<'tcx>(`
`353`	`353`	`// are shared between mir_for_ctfe and optimized_mir`
`354`	`354`	`writer.write_mir_fn(tcx.mir_for_ctfe(def_id), w)?;`
`355`	`355`	`} else {`
`356`		`- let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));`
`357`		`- render_body(w, instance_mir)?;`
	`356`	`+ if tcx.is_trivial_const(def_id).is_none() {`
	`357`	`+ let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));`
	`358`	`+ render_body(w, instance_mir)?;`
	`359`	`+ }`
`358`	`360`	`}`
`359`	`361`	`}`
`360`	`362`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -160,6 +160,14 @@ impl EraseType for Result<mir::ConstValue, mir::interpret::ErrorHandled> {`
`160`	`160`	`type Result = [u8; size_of::<Result<mir::ConstValue, mir::interpret::ErrorHandled>>()];`
`161`	`161`	`}`
`162`	`162`
	`163`	`+impl EraseType for Option<mir::ConstValue> {`
	`164`	`+ type Result = [u8; size_of::<Option<mir::ConstValue>>()];`
	`165`	`+}`
	`166`	`+`
	`167`	`+impl EraseType for Option<(mir::ConstValue, Ty<'_>)> {`
	`168`	`+ type Result = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];`
	`169`	`+}`
	`170`	`+`
`163`	`171`	`impl EraseType for EvalToValTreeResult<'_> {`
`164`	`172`	`type Result = [u8; size_of::<EvalToValTreeResult<'static>>()];`
`165`	`173`	`}`