Rollup merge of #122480 - oli-obk:const-eval-span-no-opt, r=RalfJung

Avoid various uses of `Option<Span>` in favor of using `DUMMY_SP` in the few cases that used `None` based on #122471 `DUMMY_SP` is already the sentinel value we have that says "no span". We don't need to wrap these `Span`s in a separate `Option`.
2024-03-18 16:27:07 +01:00 · 2024-03-18 16:27:07 +01:00 · 4608079604
commit 4608079604
parent 3cdcdaf31b adda9da604
34 changed files with 70 additions and 75 deletions
--- a/compiler/rustc_codegen_cranelift/src/constant.rs
+++ b/compiler/rustc_codegen_cranelift/src/constant.rs
@ -74,7 +74,7 @@ pub(crate) fn eval_mir_constant<'tcx>(
    let cv = fx.monomorphize(constant.const_);
    // This cannot fail because we checked all required_consts in advance.
    let val = cv
-        .eval(fx.tcx, ty::ParamEnv::reveal_all(), Some(constant.span))
+        .eval(fx.tcx, ty::ParamEnv::reveal_all(), constant.span)
        .expect("erroneous constant missed by mono item collection");
    (val, cv.ty())
 }
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@ -728,8 +728,10 @@ fn codegen_regular_intrinsic_call<'tcx>(
        | sym::variant_count => {
            intrinsic_args!(fx, args => (); intrinsic);

-            let const_val =
-                fx.tcx.const_eval_instance(ParamEnv::reveal_all(), instance, None).unwrap();
+            let const_val = fx
+                .tcx
+                .const_eval_instance(ParamEnv::reveal_all(), instance, source_info.span)
+                .unwrap();
            let val = crate::constant::codegen_const_value(fx, const_val, ret.layout().ty);
            ret.write_cvalue(fx, val);
        }
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@ -131,7 +131,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(

            let idx = generic_args[2]
                .expect_const()
-                .eval(fx.tcx, ty::ParamEnv::reveal_all(), Some(span))
+                .eval(fx.tcx, ty::ParamEnv::reveal_all(), span)
                .unwrap()
                .unwrap_branch();

--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@ -1129,7 +1129,7 @@ macro_rules! require_simd {
    if name == sym::simd_shuffle_generic {
        let idx = fn_args[2]
            .expect_const()
-            .eval(tcx, ty::ParamEnv::reveal_all(), Some(span))
+            .eval(tcx, ty::ParamEnv::reveal_all(), span)
            .unwrap()
            .unwrap_branch();
        let n = idx.len() as u64;
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@ -19,6 +19,7 @@
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
 use rustc_middle::ty::{self, ExistentialProjection, ParamEnv, Ty, TyCtxt};
 use rustc_middle::ty::{GenericArgKind, GenericArgsRef};
+use rustc_span::DUMMY_SP;
 use rustc_target::abi::Integer;
 use smallvec::SmallVec;

@ -704,7 +705,7 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
                // avoiding collisions and will make the emitted type names shorter.
                let hash_short = tcx.with_stable_hashing_context(|mut hcx| {
                    let mut hasher = StableHasher::new();
-                    let ct = ct.eval(tcx, ty::ParamEnv::reveal_all(), None).unwrap();
+                    let ct = ct.eval(tcx, ty::ParamEnv::reveal_all(), DUMMY_SP).unwrap();
                    hcx.while_hashing_spans(false, |hcx| ct.hash_stable(hcx, &mut hasher));
                    hasher.finish::<Hash64>()
                });
--- a/compiler/rustc_codegen_ssa/src/mir/constant.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/constant.rs
@ -24,7 +24,7 @@ pub fn eval_mir_constant(&self, constant: &mir::ConstOperand<'tcx>) -> mir::Cons
        // `MirUsedCollector` visited all required_consts before codegen began, so if we got here
        // there can be no more constants that fail to evaluate.
        self.monomorphize(constant.const_)
-            .eval(self.cx.tcx(), ty::ParamEnv::reveal_all(), Some(constant.span))
+            .eval(self.cx.tcx(), ty::ParamEnv::reveal_all(), constant.span)
            .expect("erroneous constant missed by mono item collection")
    }

@ -56,11 +56,7 @@ pub fn eval_unevaluated_mir_constant_to_valtree(
            other => span_bug!(constant.span, "{other:#?}"),
        };
        let uv = self.monomorphize(uv);
-        self.cx.tcx().const_eval_resolve_for_typeck(
-            ty::ParamEnv::reveal_all(),
-            uv,
-            Some(constant.span),
-        )
+        self.cx.tcx().const_eval_resolve_for_typeck(ty::ParamEnv::reveal_all(), uv, constant.span)
    }

    /// process constant containing SIMD shuffle indices
--- a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs
@ -130,7 +130,7 @@ pub fn codegen_intrinsic_call(
            | sym::variant_count => {
                let value = bx
                    .tcx()
-                    .const_eval_instance(ty::ParamEnv::reveal_all(), instance, None)
+                    .const_eval_instance(ty::ParamEnv::reveal_all(), instance, span)
                    .unwrap();
                OperandRef::from_const(bx, value, ret_ty).immediate_or_packed_pair(bx)
            }
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@ -826,7 +826,7 @@ pub fn push_stack_frame(
            for &const_ in &body.required_consts {
                let c = self
                    .instantiate_from_current_frame_and_normalize_erasing_regions(const_.const_)?;
-                c.eval(*self.tcx, self.param_env, Some(const_.span)).map_err(|err| {
+                c.eval(*self.tcx, self.param_env, const_.span).map_err(|err| {
                    err.emit_note(*self.tcx);
                    err
                })?;
@ -1174,7 +1174,7 @@ pub fn eval_global(
    pub fn eval_mir_constant(
        &self,
        val: &mir::Const<'tcx>,
-        span: Option<Span>,
+        span: Span,
        layout: Option<TyAndLayout<'tcx>>,
    ) -> InterpResult<'tcx, OpTy<'tcx, M::Provenance>> {
        M::eval_mir_constant(self, *val, span, layout, |ecx, val, span, layout| {
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@ -153,9 +153,8 @@ pub fn emulate_intrinsic(
                    sym::type_name => Ty::new_static_str(self.tcx.tcx),
                    _ => bug!(),
                };
-                let val = self.ctfe_query(|tcx| {
-                    tcx.const_eval_global_id(self.param_env, gid, Some(tcx.span))
-                })?;
+                let val =
+                    self.ctfe_query(|tcx| tcx.const_eval_global_id(self.param_env, gid, tcx.span))?;
                let val = self.const_val_to_op(val, ty, Some(dest.layout))?;
                self.copy_op(&val, dest)?;
            }
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@ -525,7 +525,7 @@ fn after_local_allocated(
    fn eval_mir_constant<F>(
        ecx: &InterpCx<'mir, 'tcx, Self>,
        val: mir::Const<'tcx>,
-        span: Option<Span>,
+        span: Span,
        layout: Option<TyAndLayout<'tcx>>,
        eval: F,
    ) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>
@ -533,7 +533,7 @@ fn eval_mir_constant<F>(
        F: Fn(
            &InterpCx<'mir, 'tcx, Self>,
            mir::Const<'tcx>,
-            Option<Span>,
+            Span,
            Option<TyAndLayout<'tcx>>,
        ) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>,
    {
--- a/compiler/rustc_const_eval/src/interpret/operand.rs
+++ b/compiler/rustc_const_eval/src/interpret/operand.rs
@ -741,7 +741,7 @@ pub fn eval_operand(
                // * During ConstProp, with `TooGeneric` or since the `required_consts` were not all
                //   checked yet.
                // * During CTFE, since promoteds in `const`/`static` initializer bodies can fail.
-                self.eval_mir_constant(&c, Some(constant.span), layout)?
+                self.eval_mir_constant(&c, constant.span, layout)?
            }
        };
        trace!("{:?}: {:?}", mir_op, op);
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@ -2178,7 +2178,7 @@ fn check_array_pat_len(
        len: ty::Const<'tcx>,
        min_len: u64,
    ) -> (Option<Ty<'tcx>>, Ty<'tcx>) {
-        let len = match len.eval(self.tcx, self.param_env, None) {
+        let len = match len.eval(self.tcx, self.param_env, span) {
            Ok(val) => val
                .try_to_scalar()
                .and_then(|scalar| scalar.try_to_int().ok())
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@ -1475,7 +1475,7 @@ pub fn try_const_eval_resolve(
        param_env: ty::ParamEnv<'tcx>,
        unevaluated: ty::UnevaluatedConst<'tcx>,
        ty: Ty<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> Result<ty::Const<'tcx>, ErrorHandled> {
        match self.const_eval_resolve(param_env, unevaluated, span) {
            Ok(Some(val)) => Ok(ty::Const::new_value(self.tcx, val, ty)),
@ -1509,7 +1509,7 @@ pub fn const_eval_resolve(
        &self,
        mut param_env: ty::ParamEnv<'tcx>,
        unevaluated: ty::UnevaluatedConst<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToValTreeResult<'tcx> {
        let mut args = self.resolve_vars_if_possible(unevaluated.args);
        debug!(?args);
@ -1521,12 +1521,9 @@ pub fn const_eval_resolve(
            if let Some(ct) = tcx.thir_abstract_const(unevaluated.def)? {
                let ct = tcx.expand_abstract_consts(ct.instantiate(tcx, args));
                if let Err(e) = ct.error_reported() {
-                    return Err(ErrorHandled::Reported(
-                        e.into(),
-                        span.unwrap_or(rustc_span::DUMMY_SP),
-                    ));
+                    return Err(ErrorHandled::Reported(e.into(), span));
                } else if ct.has_non_region_infer() || ct.has_non_region_param() {
-                    return Err(ErrorHandled::TooGeneric(span.unwrap_or(rustc_span::DUMMY_SP)));
+                    return Err(ErrorHandled::TooGeneric(span));
                } else {
                    args = replace_param_and_infer_args_with_placeholder(tcx, args);
                }
--- a/compiler/rustc_middle/src/mir/consts.rs
+++ b/compiler/rustc_middle/src/mir/consts.rs
@ -2,7 +2,7 @@

 use rustc_hir::def_id::DefId;
 use rustc_session::RemapFileNameExt;
-use rustc_span::Span;
+use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::{HasDataLayout, Size};

 use crate::mir::interpret::{alloc_range, AllocId, ConstAllocation, ErrorHandled, Scalar};
@ -273,7 +273,7 @@ pub fn eval(
        self,
        tcx: TyCtxt<'tcx>,
        param_env: ty::ParamEnv<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> Result<ConstValue<'tcx>, ErrorHandled> {
        match self {
            Const::Ty(c) => {
@ -293,7 +293,7 @@ pub fn eval(
    /// Normalizes the constant to a value or an error if possible.
    #[inline]
    pub fn normalize(self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self {
-        match self.eval(tcx, param_env, None) {
+        match self.eval(tcx, param_env, DUMMY_SP) {
            Ok(val) => Self::Val(val, self.ty()),
            Err(ErrorHandled::Reported(guar, _span)) => {
                Self::Ty(ty::Const::new_error(tcx, guar.into(), self.ty()))
@ -313,10 +313,10 @@ pub fn try_eval_scalar(
                // Avoid the `valtree_to_const_val` query. Can only be done on primitive types that
                // are valtree leaves, and *not* on references. (References should return the
                // pointer here, which valtrees don't represent.)
-                let val = c.eval(tcx, param_env, None).ok()?;
+                let val = c.eval(tcx, param_env, DUMMY_SP).ok()?;
                Some(val.unwrap_leaf().into())
            }
-            _ => self.eval(tcx, param_env, None).ok()?.try_to_scalar(),
+            _ => self.eval(tcx, param_env, DUMMY_SP).ok()?.try_to_scalar(),
        }
    }

--- a/compiler/rustc_middle/src/mir/interpret/queries.rs
+++ b/compiler/rustc_middle/src/mir/interpret/queries.rs
@ -24,7 +24,7 @@ pub fn const_eval_poly(self, def_id: DefId) -> EvalToConstValueResult<'tcx> {
        let instance = ty::Instance::new(def_id, args);
        let cid = GlobalId { instance, promoted: None };
        let param_env = self.param_env(def_id).with_reveal_all_normalized(self);
-        self.const_eval_global_id(param_env, cid, None)
+        self.const_eval_global_id(param_env, cid, DUMMY_SP)
    }
    /// Resolves and evaluates a constant.
    ///
@ -40,7 +40,7 @@ pub fn const_eval_resolve(
        self,
        param_env: ty::ParamEnv<'tcx>,
        ct: mir::UnevaluatedConst<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToConstValueResult<'tcx> {
        // Cannot resolve `Unevaluated` constants that contain inference
        // variables. We reject those here since `resolve`
@ -73,7 +73,7 @@ pub fn const_eval_resolve_for_typeck(
        self,
        param_env: ty::ParamEnv<'tcx>,
        ct: ty::UnevaluatedConst<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToValTreeResult<'tcx> {
        // Cannot resolve `Unevaluated` constants that contain inference
        // variables. We reject those here since `resolve`
@ -130,7 +130,7 @@ pub fn const_eval_instance(
        self,
        param_env: ty::ParamEnv<'tcx>,
        instance: ty::Instance<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToConstValueResult<'tcx> {
        self.const_eval_global_id(param_env, GlobalId { instance, promoted: None }, span)
    }
@ -141,12 +141,12 @@ pub fn const_eval_global_id(
        self,
        param_env: ty::ParamEnv<'tcx>,
        cid: GlobalId<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToConstValueResult<'tcx> {
        // Const-eval shouldn't depend on lifetimes at all, so we can erase them, which should
        // improve caching of queries.
        let inputs = self.erase_regions(param_env.with_reveal_all_normalized(self).and(cid));
-        if let Some(span) = span {
+        if !span.is_dummy() {
            // The query doesn't know where it is being invoked, so we need to fix the span.
            self.at(span).eval_to_const_value_raw(inputs).map_err(|e| e.with_span(span))
        } else {
@ -160,13 +160,13 @@ pub fn const_eval_global_id_for_typeck(
        self,
        param_env: ty::ParamEnv<'tcx>,
        cid: GlobalId<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToValTreeResult<'tcx> {
        // Const-eval shouldn't depend on lifetimes at all, so we can erase them, which should
        // improve caching of queries.
        let inputs = self.erase_regions(param_env.with_reveal_all_normalized(self).and(cid));
        debug!(?inputs);
-        if let Some(span) = span {
+        if !span.is_dummy() {
            // The query doesn't know where it is being invoked, so we need to fix the span.
            self.at(span).eval_to_valtree(inputs).map_err(|e| e.with_span(span))
        } else {
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@ -335,7 +335,7 @@ pub fn eval(
        self,
        tcx: TyCtxt<'tcx>,
        param_env: ParamEnv<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> Result<ValTree<'tcx>, ErrorHandled> {
        assert!(!self.has_escaping_bound_vars(), "escaping vars in {self:?}");
        match self.kind() {
@ -349,7 +349,7 @@ pub fn eval(
                else {
                    // This can happen when we run on ill-typed code.
                    let e = tcx.dcx().span_delayed_bug(
-                        span.unwrap_or(DUMMY_SP),
+                        span,
                        "`ty::Const::eval` called on a non-valtree-compatible type",
                    );
                    return Err(e.into());
@ -362,14 +362,14 @@ pub fn eval(
            | ConstKind::Infer(_)
            | ConstKind::Bound(_, _)
            | ConstKind::Placeholder(_)
-            | ConstKind::Expr(_) => Err(ErrorHandled::TooGeneric(span.unwrap_or(DUMMY_SP))),
+            | ConstKind::Expr(_) => Err(ErrorHandled::TooGeneric(span)),
        }
    }

    /// Normalizes the constant to a value or an error if possible.
    #[inline]
    pub fn normalize(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> Self {
-        match self.eval(tcx, param_env, None) {
+        match self.eval(tcx, param_env, DUMMY_SP) {
            Ok(val) => Self::new_value(tcx, val, self.ty()),
            Err(ErrorHandled::Reported(r, _span)) => Self::new_error(tcx, r.into(), self.ty()),
            Err(ErrorHandled::TooGeneric(_span)) => self,
@ -382,7 +382,7 @@ pub fn try_eval_scalar(
        tcx: TyCtxt<'tcx>,
        param_env: ty::ParamEnv<'tcx>,
    ) -> Option<Scalar> {
-        self.eval(tcx, param_env, None).ok()?.try_to_scalar()
+        self.eval(tcx, param_env, DUMMY_SP).ok()?.try_to_scalar()
    }

    #[inline]
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@ -524,12 +524,12 @@ fn lower_path(&mut self, qpath: &hir::QPath<'_>, id: hir::HirId, span: Span) ->
        // Prefer valtrees over opaque constants.
        let const_value = self
            .tcx
-            .const_eval_global_id_for_typeck(param_env_reveal_all, cid, Some(span))
+            .const_eval_global_id_for_typeck(param_env_reveal_all, cid, span)
            .map(|val| match val {
                Some(valtree) => mir::Const::Ty(ty::Const::new_value(self.tcx, valtree, ty)),
                None => mir::Const::Val(
                    self.tcx
-                        .const_eval_global_id(param_env_reveal_all, cid, Some(span))
+                        .const_eval_global_id(param_env_reveal_all, cid, span)
                        .expect("const_eval_global_id_for_typeck should have already failed"),
                    ty,
                ),
@ -627,15 +627,14 @@ fn lower_inline_const(
        // First try using a valtree in order to destructure the constant into a pattern.
        // FIXME: replace "try to do a thing, then fall back to another thing"
        // but something more principled, like a trait query checking whether this can be turned into a valtree.
-        if let Ok(Some(valtree)) =
-            self.tcx.const_eval_resolve_for_typeck(self.param_env, ct, Some(span))
+        if let Ok(Some(valtree)) = self.tcx.const_eval_resolve_for_typeck(self.param_env, ct, span)
        {
            let subpattern =
                self.const_to_pat(Const::Ty(ty::Const::new_value(self.tcx, valtree, ty)), id, span);
            PatKind::InlineConstant { subpattern, def: def_id }
        } else {
            // If that fails, convert it to an opaque constant pattern.
-            match tcx.const_eval_resolve(self.param_env, uneval, Some(span)) {
+            match tcx.const_eval_resolve(self.param_env, uneval, span) {
                Ok(val) => self.const_to_pat(mir::Const::Val(val, ty), id, span).kind,
                Err(ErrorHandled::TooGeneric(_)) => {
                    // If we land here it means the const can't be evaluated because it's `TooGeneric`.
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@ -394,7 +394,7 @@ fn assign_operand(
            }
            Operand::Constant(box constant) => {
                if let Ok(constant) =
-                    self.ecx.eval_mir_constant(&constant.const_, Some(constant.span), None)
+                    self.ecx.eval_mir_constant(&constant.const_, constant.span, None)
                {
                    self.assign_constant(state, place, constant, &[]);
                }
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@ -367,7 +367,7 @@ fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
            Repeat(..) => return None,

            Constant { ref value, disambiguator: _ } => {
-                self.ecx.eval_mir_constant(value, None, None).ok()?
+                self.ecx.eval_mir_constant(value, DUMMY_SP, None).ok()?
            }
            Aggregate(kind, variant, ref fields) => {
                let fields = fields
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@ -417,7 +417,7 @@ fn process_operand(
            // If we expect `lhs ?= A`, we have an opportunity if we assume `constant == A`.
            Operand::Constant(constant) => {
                let constant =
-                    self.ecx.eval_mir_constant(&constant.const_, Some(constant.span), None).ok()?;
+                    self.ecx.eval_mir_constant(&constant.const_, constant.span, None).ok()?;
                self.process_constant(bb, lhs, constant, state);
            }
            // Transfer the conditions on the copied rhs.
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@ -261,7 +261,7 @@ fn eval_constant(&mut self, c: &ConstOperand<'tcx>) -> Option<ImmTy<'tcx>> {
        // manually normalized.
        let val = self.tcx.try_normalize_erasing_regions(self.param_env, c.const_).ok()?;

-        self.use_ecx(|this| this.ecx.eval_mir_constant(&val, Some(c.span), None))?
+        self.use_ecx(|this| this.ecx.eval_mir_constant(&val, c.span, None))?
            .as_mplace_or_imm()
            .right()
    }
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@ -828,7 +828,7 @@ fn visit_constant(&mut self, constant: &mir::ConstOperand<'tcx>, location: Locat
        // a codegen-time error). rustc stops after collection if there was an error, so this
        // ensures codegen never has to worry about failing consts.
        // (codegen relies on this and ICEs will happen if this is violated.)
-        let val = match const_.eval(self.tcx, param_env, Some(constant.span)) {
+        let val = match const_.eval(self.tcx, param_env, constant.span) {
            Ok(v) => v,
            Err(ErrorHandled::TooGeneric(..)) => span_bug!(
                self.body.source_info(location).span,
--- a/compiler/rustc_smir/src/rustc_smir/builder.rs
+++ b/compiler/rustc_smir/src/rustc_smir/builder.rs
@ -56,7 +56,7 @@ fn visit_ty(&mut self, ty: &mut Ty<'tcx>, _: mir::visit::TyContext) {

    fn visit_constant(&mut self, constant: &mut mir::ConstOperand<'tcx>, location: mir::Location) {
        let const_ = self.monomorphize(constant.const_);
-        let val = match const_.eval(self.tcx, ty::ParamEnv::reveal_all(), Some(constant.span)) {
+        let val = match const_.eval(self.tcx, ty::ParamEnv::reveal_all(), constant.span) {
            Ok(v) => v,
            Err(mir::interpret::ErrorHandled::Reported(..)) => return,
            Err(mir::interpret::ErrorHandled::TooGeneric(..)) => {
--- a/compiler/rustc_smir/src/rustc_smir/context.rs
+++ b/compiler/rustc_smir/src/rustc_smir/context.rs
@ -566,7 +566,7 @@ fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Er
        let result = tcx.const_eval_instance(
            ParamEnv::reveal_all(),
            instance,
-            Some(tcx.def_span(instance.def_id())),
+            tcx.def_span(instance.def_id()),
        );
        result
            .map(|const_val| {
--- a/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs
@ -968,7 +968,7 @@ pub(super) fn try_const_eval_resolve(
        ty: Ty<'tcx>,
    ) -> Option<ty::Const<'tcx>> {
        use rustc_middle::mir::interpret::ErrorHandled;
-        match self.infcx.try_const_eval_resolve(param_env, unevaluated, ty, None) {
+        match self.infcx.try_const_eval_resolve(param_env, unevaluated, ty, DUMMY_SP) {
            Ok(ct) => Some(ct),
            Err(ErrorHandled::Reported(e, _)) => {
                Some(ty::Const::new_error(self.tcx(), e.into(), ty))
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@ -786,7 +786,7 @@ fn evaluate_nested_obligations(
                            match selcx.infcx.const_eval_resolve(
                                obligation.param_env,
                                unevaluated,
-                                Some(obligation.cause.span),
+                                obligation.cause.span,
                            ) {
                                Ok(Some(valtree)) => Ok(ty::Const::new_value(selcx.tcx(),valtree, c.ty())),
                                Ok(None) => {
--- a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
+++ b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
@ -68,7 +68,7 @@ pub fn is_const_evaluatable<'tcx>(
                tcx.dcx().span_bug(span, "evaluating `ConstKind::Expr` is not currently supported");
            }
            ty::ConstKind::Unevaluated(uv) => {
-                let concrete = infcx.const_eval_resolve(param_env, uv, Some(span));
+                let concrete = infcx.const_eval_resolve(param_env, uv, span);
                match concrete {
                    Err(ErrorHandled::TooGeneric(_)) => {
                        Err(NotConstEvaluatable::Error(infcx.dcx().span_delayed_bug(
@ -99,7 +99,7 @@ pub fn is_const_evaluatable<'tcx>(
        // and hopefully soon change this to an error.
        //
        // See #74595 for more details about this.
-        let concrete = infcx.const_eval_resolve(param_env, uv, Some(span));
+        let concrete = infcx.const_eval_resolve(param_env, uv, span);
        match concrete {
            // If we're evaluating a generic foreign constant, under a nightly compiler while
            // the current crate does not enable `feature(generic_const_exprs)`, abort
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@ -600,7 +600,7 @@ fn process_obligation(
                                obligation.param_env,
                                unevaluated,
                                c.ty(),
-                                Some(obligation.cause.span),
+                                obligation.cause.span,
                            ) {
                                Ok(val) => Ok(val),
                                Err(e) => {
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@ -949,7 +949,7 @@ fn evaluate_predicate_recursively<'o>(
                                obligation.param_env,
                                unevaluated,
                                c.ty(),
-                                Some(obligation.cause.span),
+                                obligation.cause.span,
                            ) {
                                Ok(val) => Ok(val),
                                Err(e) => Err(e),
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@ -89,6 +89,7 @@ mod rustc {
    use rustc_middle::ty::Ty;
    use rustc_middle::ty::TyCtxt;
    use rustc_middle::ty::ValTree;
+    use rustc_span::DUMMY_SP;

    /// The source and destination types of a transmutation.
    #[derive(TypeVisitable, Debug, Clone, Copy)]
@ -135,7 +136,7 @@ pub fn from_const<'tcx>(
            use rustc_middle::ty::ScalarInt;
            use rustc_span::symbol::sym;

-            let Ok(cv) = c.eval(tcx, param_env, None) else {
+            let Ok(cv) = c.eval(tcx, param_env, DUMMY_SP) else {
                return Some(Self {
                    alignment: true,
                    lifetimes: true,
--- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs
+++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@ -290,14 +290,14 @@ fn is_value_unfrozen_poly<'tcx>(&self, cx: &LateContext<'tcx>, body_id: BodyId,
            promoted: None,
        };
        let param_env = cx.tcx.param_env(def_id).with_reveal_all_normalized(cx.tcx);
-        let result = cx.tcx.const_eval_global_id_for_typeck(param_env, cid, None);
+        let result = cx.tcx.const_eval_global_id_for_typeck(param_env, cid, rustc_span::DUMMY_SP);
        self.is_value_unfrozen_raw(cx, result, ty)
    }

    fn is_value_unfrozen_expr<'tcx>(&self, cx: &LateContext<'tcx>, hir_id: HirId, def_id: DefId, ty: Ty<'tcx>) -> bool {
        let args = cx.typeck_results().node_args(hir_id);

-        let result = Self::const_eval_resolve(cx.tcx, cx.param_env, ty::UnevaluatedConst::new(def_id, args), None);
+        let result = Self::const_eval_resolve(cx.tcx, cx.param_env, ty::UnevaluatedConst::new(def_id, args), rustc_span::DUMMY_SP);
        self.is_value_unfrozen_raw(cx, result, ty)
    }

@ -305,7 +305,7 @@ pub fn const_eval_resolve<'tcx>(
        tcx: TyCtxt<'tcx>,
        param_env: ty::ParamEnv<'tcx>,
        ct: ty::UnevaluatedConst<'tcx>,
-        span: Option<Span>,
+        span: Span,
    ) -> EvalToValTreeResult<'tcx> {
        match ty::Instance::resolve(tcx, param_env, ct.def, ct.args) {
            Ok(Some(instance)) => {
@ -315,8 +315,8 @@ pub fn const_eval_resolve<'tcx>(
                };
                tcx.const_eval_global_id_for_typeck(param_env, cid, span)
            },
-            Ok(None) => Err(ErrorHandled::TooGeneric(span.unwrap_or(rustc_span::DUMMY_SP))),
-            Err(err) => Err(ErrorHandled::Reported(err.into(), span.unwrap_or(rustc_span::DUMMY_SP))),
+            Ok(None) => Err(ErrorHandled::TooGeneric(span)),
+            Err(err) => Err(ErrorHandled::Reported(err.into(), span)),
        }
    }
 }
--- a/src/tools/clippy/clippy_utils/src/consts.rs
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@ -550,7 +550,7 @@ fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<C
                let result = self
                    .lcx
                    .tcx
-                    .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, args), None)
+                    .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, args), qpath.span())
                    .ok()
                    .map(|val| rustc_middle::mir::Const::from_value(val, ty))?;
                let result = mir_to_const(self.lcx, result)?;
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@ -1503,7 +1503,7 @@ fn after_local_allocated(
    fn eval_mir_constant<F>(
        ecx: &InterpCx<'mir, 'tcx, Self>,
        val: mir::Const<'tcx>,
-        span: Option<Span>,
+        span: Span,
        layout: Option<TyAndLayout<'tcx>>,
        eval: F,
    ) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>
@ -1511,7 +1511,7 @@ fn eval_mir_constant<F>(
        F: Fn(
            &InterpCx<'mir, 'tcx, Self>,
            mir::Const<'tcx>,
-            Option<Span>,
+            Span,
            Option<TyAndLayout<'tcx>>,
        ) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>,
    {
--- a/src/tools/miri/src/shims/intrinsics/simd.rs
+++ b/src/tools/miri/src/shims/intrinsics/simd.rs
@ -549,7 +549,7 @@ enum Op {

                let index = generic_args[2]
                    .expect_const()
-                    .eval(*this.tcx, this.param_env(), Some(this.tcx.span))
+                    .eval(*this.tcx, this.param_env(), this.tcx.span)
                    .unwrap()
                    .unwrap_branch();
                let index_len = index.len();