Rollup merge of rust-lang#72538 - rakshith-ravi:refactor/remove-const-query, r=oli-obk

Removed all instances of const_field.

Fixes rust-lang#72264

r? @oli-obk

Author: Dylan-DPC

src/librustc_codegen_ssa/mir/constant.rs

@@ -1,6 +1,5 @@
 use crate::mir::operand::OperandRef;
 use crate::traits::*;
-use rustc_index::vec::Idx;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::{ConstValue, ErrorHandled};
 use rustc_middle::ty::layout::HasTyCtxt;
@@ -59,17 +58,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         constant
             .map(|val| {
                 let field_ty = ty.builtin_index().unwrap();
-                let fields = match ty.kind {
-                    ty::Array(_, n) => n.eval_usize(bx.tcx(), ty::ParamEnv::reveal_all()),
-                    _ => bug!("invalid simd shuffle type: {}", ty),
-                };
                 let c = ty::Const::from_value(bx.tcx(), val, ty);
-                let values: Vec<_> = (0..fields)
+                let values: Vec<_> = bx
+                    .tcx()
+                    .destructure_const(ty::ParamEnv::reveal_all().and(&c))
+                    .fields
+                    .into_iter()
                     .map(|field| {
-                        let field = bx.tcx().const_field(
-                            ty::ParamEnv::reveal_all().and((&c, mir::Field::new(field as usize))),
-                        );
-                        if let Some(prim) = field.try_to_scalar() {
+                        if let Some(prim) = field.val.try_to_scalar() {
                             let layout = bx.layout_of(field_ty);
                             let scalar = match layout.abi {
                                 Abi::Scalar(ref x) => x,

src/librustc_middle/dep_graph/dep_node.rs

@@ -49,7 +49,6 @@
 //! user of the `DepNode` API of having to know how to compute the expected
 //! fingerprint for a given set of node parameters.
 
-use crate::mir;
 use crate::mir::interpret::{GlobalId, LitToConstInput};
 use crate::traits;
 use crate::traits::query::{

src/librustc_middle/query/mod.rs

@@ -1,5 +1,4 @@
 use crate::dep_graph::SerializedDepNodeIndex;
-use crate::mir;
 use crate::mir::interpret::{GlobalId, LitToConstInput};
 use crate::traits;
 use crate::traits::query::{
@@ -553,13 +552,6 @@ rustc_queries! {
             }
         }
 
-        /// Extracts a field of a (variant of a) const.
-        query const_field(
-            key: ty::ParamEnvAnd<'tcx, (&'tcx ty::Const<'tcx>, mir::Field)>
-        ) -> ConstValue<'tcx> {
-            desc { "extract field of const" }
-        }
-
         /// Destructure a constant ADT or array into its variant index and its
         /// field values.
         query destructure_const(

src/librustc_mir/const_eval/eval_queries.rs

@@ -122,7 +122,7 @@ pub(super) fn op_to_const<'tcx>(
     } else {
         // It is guaranteed that any non-slice scalar pair is actually ByRef here.
         // When we come back from raw const eval, we are always by-ref. The only way our op here is
-        // by-val is if we are in const_field, i.e., if this is (a field of) something that we
+        // by-val is if we are in destructure_const, i.e., if this is (a field of) something that we
         // "tried to make immediate" before. We wouldn't do that for non-slice scalar pairs or
         // structs containing such.
         op.try_as_mplace(ecx)

src/librustc_mir/const_eval/mod.rs

@@ -5,7 +5,6 @@ use std::convert::TryFrom;
 use rustc_middle::mir;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::{source_map::DUMMY_SP, symbol::Symbol};
-use rustc_target::abi::VariantIdx;
 
 use crate::interpret::{intern_const_alloc_recursive, ConstValue, InternKind, InterpCx};
 
@@ -19,32 +18,6 @@ pub use eval_queries::*;
 pub use fn_queries::*;
 pub use machine::*;
 
-/// Extracts a field of a (variant of a) const.
-// this function uses `unwrap` copiously, because an already validated constant must have valid
-// fields and can thus never fail outside of compiler bugs
-pub(crate) fn const_field<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    variant: Option<VariantIdx>,
-    field: mir::Field,
-    value: &'tcx ty::Const<'tcx>,
-) -> ConstValue<'tcx> {
-    trace!("const_field: {:?}, {:?}", field, value);
-    let ecx = mk_eval_cx(tcx, DUMMY_SP, param_env, false);
-    // get the operand again
-    let op = ecx.eval_const_to_op(value, None).unwrap();
-    // downcast
-    let down = match variant {
-        None => op,
-        Some(variant) => ecx.operand_downcast(op, variant).unwrap(),
-    };
-    // then project
-    let field = ecx.operand_field(down, field.index()).unwrap();
-    // and finally move back to the const world, always normalizing because
-    // this is not called for statics.
-    op_to_const(&ecx, field)
-}
-
 pub(crate) fn const_caller_location(
     tcx: TyCtxt<'tcx>,
     (file, line, col): (Symbol, u32, u32),

src/librustc_mir/lib.rs

@@ -56,10 +56,6 @@ pub fn provide(providers: &mut Providers<'_>) {
     providers.const_eval_validated = const_eval::const_eval_validated_provider;
     providers.const_eval_raw = const_eval::const_eval_raw_provider;
     providers.const_caller_location = const_eval::const_caller_location;
-    providers.const_field = |tcx, param_env_and_value| {
-        let (param_env, (value, field)) = param_env_and_value.into_parts();
-        const_eval::const_field(tcx, param_env, None, field, value)
-    };
     providers.destructure_const = |tcx, param_env_and_value| {
         let (param_env, value) = param_env_and_value.into_parts();
         const_eval::destructure_const(tcx, param_env, value)