improve naming

Author: lcnr

src/librustc_infer/infer/mod.rs

@@ -1536,7 +1536,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     pub fn const_eval_resolve(
         &self,
         param_env: ty::ParamEnv<'tcx>,
-        def: ty::WithOptParam<DefId>,
+        def: ty::WithOptConstParam<DefId>,
         substs: SubstsRef<'tcx>,
         promoted: Option<mir::Promoted>,
         span: Option<Span>,

src/librustc_interface/passes.rs

@@ -892,7 +892,7 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
 
             if tcx.hir().body_const_context(def_id).is_some() {
                 tcx.ensure()
-                    .mir_drops_elaborated_and_const_checked(ty::WithOptParam::dummy(def_id));
+                    .mir_drops_elaborated_and_const_checked(ty::WithOptConstParam::dummy(def_id));
             }
         }
     });

src/librustc_middle/mir/interpret/queries.rs

@@ -34,7 +34,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn const_eval_resolve(
         self,
         param_env: ty::ParamEnv<'tcx>,
-        def: ty::WithOptParam<DefId>,
+        def: ty::WithOptConstParam<DefId>,
         substs: SubstsRef<'tcx>,
         promoted: Option<mir::Promoted>,
         span: Option<Span>,

src/librustc_middle/mir/query.rs

@@ -328,17 +328,20 @@ pub struct CoverageInfo {
 impl<'tcx> TyCtxt<'tcx> {
     pub fn mir_borrowck_opt_const_arg(
         self,
-        def: ty::WithOptParam<LocalDefId>,
+        def: ty::WithOptConstParam<LocalDefId>,
     ) -> &'tcx BorrowCheckResult<'tcx> {
-        if let Some(param_did) = def.param_did {
+        if let Some(param_did) = def.const_param_did {
             self.mir_borrowck_const_arg((def.did, param_did))
         } else {
             self.mir_borrowck(def.did)
         }
     }
 
-    pub fn mir_const_qualif_opt_const_arg(self, def: ty::WithOptParam<LocalDefId>) -> ConstQualifs {
-        if let Some(param_did) = def.param_did {
+    pub fn mir_const_qualif_opt_const_arg(
+        self,
+        def: ty::WithOptConstParam<LocalDefId>,
+    ) -> ConstQualifs {
+        if let Some(param_did) = def.const_param_did {
             self.mir_const_qualif_const_arg((def.did, param_did))
         } else {
             self.mir_const_qualif(def.did)
@@ -347,7 +350,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     pub fn promoted_mir_of_opt_const_arg(
         self,
-        def: ty::WithOptParam<DefId>,
+        def: ty::WithOptConstParam<DefId>,
     ) -> &'tcx IndexVec<Promoted, Body<'tcx>> {
         if let Some((did, param_did)) = def.as_const_arg() {
             self.promoted_mir_of_const_arg((did, param_did))

src/librustc_middle/query/mod.rs

@@ -105,7 +105,7 @@ rustc_queries! {
         /// ```
         query opt_const_param_of(key: LocalDefId) -> Option<DefId> {
             desc { |tcx| "computing the optional const parameter of `{}`", tcx.def_path_str(key.to_def_id()) }
-            // FIXME: consider storing this query on disk.
+            // FIXME(#74113): consider storing this query on disk.
         }
 
         /// Records the type of every item.
@@ -219,39 +219,39 @@ rustc_queries! {
 
         /// Fetch the MIR for a given `DefId` right after it's built - this includes
         /// unreachable code.
-        query mir_built(key: ty::WithOptParam<LocalDefId>) -> &'tcx Steal<mir::Body<'tcx>> {
+        query mir_built(key: ty::WithOptConstParam<LocalDefId>) -> &'tcx Steal<mir::Body<'tcx>> {
             desc { |tcx| "building MIR for `{}`", tcx.def_path_str(key.did.to_def_id()) }
         }
 
         /// Fetch the MIR for a given `DefId` up till the point where it is
         /// ready for const qualification.
         ///
         /// See the README for the `mir` module for details.
-        query mir_const(key: ty::WithOptParam<LocalDefId>) -> &'tcx Steal<mir::Body<'tcx>> {
+        query mir_const(key: ty::WithOptConstParam<LocalDefId>) -> &'tcx Steal<mir::Body<'tcx>> {
             desc {
                 |tcx| "processing MIR for {}`{}`",
-                if key.param_did.is_some() { "the const argument " } else { "" },
+                if key.const_param_did.is_some() { "the const argument " } else { "" },
                 tcx.def_path_str(key.did.to_def_id()),
             }
             no_hash
         }
 
         query mir_drops_elaborated_and_const_checked(
-            key: ty::WithOptParam<LocalDefId>
+            key: ty::WithOptConstParam<LocalDefId>
         ) -> &'tcx Steal<mir::Body<'tcx>> {
             no_hash
             desc { |tcx| "elaborating drops for `{}`", tcx.def_path_str(key.did.to_def_id()) }
         }
 
-        query mir_validated(key: ty::WithOptParam<LocalDefId>) ->
+        query mir_validated(key: ty::WithOptConstParam<LocalDefId>) ->
             (
                 &'tcx Steal<mir::Body<'tcx>>,
                 &'tcx Steal<IndexVec<mir::Promoted, mir::Body<'tcx>>>
             ) {
             no_hash
             desc {
                 |tcx| "processing {}`{}`",
-                if key.param_did.is_some() { "the const argument " } else { "" },
+                if key.const_param_did.is_some() { "the const argument " } else { "" },
                 tcx.def_path_str(key.did.to_def_id()),
             }
         }

src/librustc_middle/ty/context.rs

@@ -982,9 +982,9 @@ pub struct GlobalCtxt<'tcx> {
 impl<'tcx> TyCtxt<'tcx> {
     pub fn typeck_tables_of_opt_const_arg(
         self,
-        def: ty::WithOptParam<LocalDefId>,
+        def: ty::WithOptConstParam<LocalDefId>,
     ) -> &'tcx TypeckTables<'tcx> {
-        if let Some(param_did) = def.param_did {
+        if let Some(param_did) = def.const_param_did {
             self.typeck_tables_of_const_arg((def.did, param_did))
         } else {
             self.typeck_tables_of(def.did)

src/librustc_middle/ty/instance.rs

@@ -29,7 +29,7 @@ pub enum InstanceDef<'tcx> {
     /// - `fn` items
     /// - closures
     /// - generators
-    Item(ty::WithOptParam<DefId>),
+    Item(ty::WithOptConstParam<DefId>),
 
     /// An intrinsic `fn` item (with `"rust-intrinsic"` or `"platform-intrinsic"` ABI).
     ///
@@ -186,7 +186,7 @@ impl<'tcx> InstanceDef<'tcx> {
     }
 
     #[inline]
-    pub fn with_opt_param(self) -> ty::WithOptParam<DefId> {
+    pub fn with_opt_param(self) -> ty::WithOptConstParam<DefId> {
         match self {
             InstanceDef::Item(def) => def,
             InstanceDef::VtableShim(def_id)
@@ -196,7 +196,7 @@ impl<'tcx> InstanceDef<'tcx> {
             | InstanceDef::Intrinsic(def_id)
             | InstanceDef::ClosureOnceShim { call_once: def_id }
             | InstanceDef::DropGlue(def_id, _)
-            | InstanceDef::CloneShim(def_id, _) => ty::WithOptParam::dummy(def_id),
+            | InstanceDef::CloneShim(def_id, _) => ty::WithOptConstParam::dummy(def_id),
         }
     }
 
@@ -298,7 +298,7 @@ impl<'tcx> Instance<'tcx> {
             def_id,
             substs
         );
-        Instance { def: InstanceDef::Item(ty::WithOptParam::dummy(def_id)), substs }
+        Instance { def: InstanceDef::Item(ty::WithOptConstParam::dummy(def_id)), substs }
     }
 
     pub fn mono(tcx: TyCtxt<'tcx>, def_id: DefId) -> Instance<'tcx> {
@@ -355,7 +355,7 @@ impl<'tcx> Instance<'tcx> {
     pub fn resolve_const_arg(
         tcx: TyCtxt<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
-        def: ty::WithOptParam<DefId>,
+        def: ty::WithOptConstParam<DefId>,
         substs: SubstsRef<'tcx>,
     ) -> Result<Option<Instance<'tcx>>, ErrorReported> {
         let substs = tcx.erase_regions(&substs);

src/librustc_middle/ty/mod.rs

@@ -1099,7 +1099,7 @@ pub enum PredicateKind<'tcx> {
     Subtype(PolySubtypePredicate<'tcx>),
 
     /// Constant initializer must evaluate successfully.
-    ConstEvaluatable(ty::WithOptParam<DefId>, SubstsRef<'tcx>),
+    ConstEvaluatable(ty::WithOptConstParam<DefId>, SubstsRef<'tcx>),
 
     /// Constants must be equal. The first component is the const that is expected.
     ConstEquate(&'tcx Const<'tcx>, &'tcx Const<'tcx>),
@@ -1601,40 +1601,42 @@ pub type PlaceholderConst = Placeholder<BoundVar>;
 #[derive(Copy, Clone, Debug, TypeFoldable, Lift, RustcEncodable, RustcDecodable)]
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 #[derive(Hash, HashStable)]
-pub struct WithOptParam<T> {
+pub struct WithOptConstParam<T> {
     pub did: T,
     /// The `DefId` of the corresponding generic paramter in case `did` is
     /// a const argument.
     ///
     /// Note that even if `did` is a const argument, this may still be `None`.
-    /// All queries taking `WithOptParam` start by calling `tcx.opt_const_param_of(def.did)`
+    /// All queries taking `WithOptConstParam` start by calling `tcx.opt_const_param_of(def.did)`
     /// to potentially update `param_did` in case it `None`.
-    pub param_did: Option<DefId>,
+    pub const_param_did: Option<DefId>,
 }
 
-impl<T> WithOptParam<T> {
-    pub fn dummy(did: T) -> WithOptParam<T> {
-        WithOptParam { did, param_did: None }
+impl<T> WithOptConstParam<T> {
+    pub fn dummy(did: T) -> WithOptConstParam<T> {
+        WithOptConstParam { did, const_param_did: None }
     }
 }
 
-impl WithOptParam<LocalDefId> {
-    pub fn to_global(self) -> WithOptParam<DefId> {
-        WithOptParam { did: self.did.to_def_id(), param_did: self.param_did }
+impl WithOptConstParam<LocalDefId> {
+    pub fn to_global(self) -> WithOptConstParam<DefId> {
+        WithOptConstParam { did: self.did.to_def_id(), const_param_did: self.const_param_did }
     }
 
     pub fn ty_def_id(self) -> DefId {
-        if let Some(did) = self.param_did { did } else { self.did.to_def_id() }
+        if let Some(did) = self.const_param_did { did } else { self.did.to_def_id() }
     }
 }
 
-impl WithOptParam<DefId> {
-    pub fn as_local(self) -> Option<WithOptParam<LocalDefId>> {
-        self.did.as_local().map(|did| WithOptParam { did, param_did: self.param_did })
+impl WithOptConstParam<DefId> {
+    pub fn as_local(self) -> Option<WithOptConstParam<LocalDefId>> {
+        self.did
+            .as_local()
+            .map(|did| WithOptConstParam { did, const_param_did: self.const_param_did })
     }
 
     pub fn as_const_arg(self) -> Option<(LocalDefId, DefId)> {
-        if let Some(param_did) = self.param_did {
+        if let Some(param_did) = self.const_param_did {
             if let Some(did) = self.did.as_local() {
                 return Some((did, param_did));
             }
@@ -1643,7 +1645,7 @@ impl WithOptParam<DefId> {
         None
     }
 
-    pub fn expect_local(self) -> WithOptParam<LocalDefId> {
+    pub fn expect_local(self) -> WithOptConstParam<LocalDefId> {
         self.as_local().unwrap()
     }
 
@@ -1652,7 +1654,7 @@ impl WithOptParam<DefId> {
     }
 
     pub fn ty_def_id(self) -> DefId {
-        self.param_did.unwrap_or(self.did)
+        self.const_param_did.unwrap_or(self.did)
     }
 }
 

src/librustc_middle/ty/query/keys.rs

@@ -105,7 +105,7 @@ impl Key for DefId {
     }
 }
 
-impl Key for ty::WithOptParam<LocalDefId> {
+impl Key for ty::WithOptConstParam<LocalDefId> {
     type CacheSelector = DefaultCacheSelector;
 
     fn query_crate(&self) -> CrateNum {

src/librustc_middle/ty/sty.rs

@@ -2210,12 +2210,12 @@ impl<'tcx> Const<'tcx> {
     /// Literals and const generic parameters are eagerly converted to a constant, everything else
     /// becomes `Unevaluated`.
     pub fn from_anon_const(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx Self {
-        Self::const_arg_from_anon_const(tcx, ty::WithOptParam::dummy(def_id))
+        Self::from_opt_const_arg_anon_const(tcx, ty::WithOptConstParam::dummy(def_id))
     }
 
-    pub fn const_arg_from_anon_const(
+    pub fn from_opt_const_arg_anon_const(
         tcx: TyCtxt<'tcx>,
-        def: ty::WithOptParam<LocalDefId>,
+        def: ty::WithOptConstParam<LocalDefId>,
     ) -> &'tcx Self {
         debug!("Const::from_anon_const(def={:?})", def);
 
@@ -2433,7 +2433,7 @@ pub enum ConstKind<'tcx> {
 
     /// Used in the HIR by using `Unevaluated` everywhere and later normalizing to one of the other
     /// variants when the code is monomorphic enough for that.
-    Unevaluated(ty::WithOptParam<DefId>, SubstsRef<'tcx>, Option<Promoted>),
+    Unevaluated(ty::WithOptConstParam<DefId>, SubstsRef<'tcx>, Option<Promoted>),
 
     /// Used to hold computed value.
     Value(ConstValue<'tcx>),