cleanup

Author: lcnr

src/librustc_middle/dep_graph/dep_node.rs

@@ -379,6 +379,7 @@ impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for ty::WithOptParam<DefId> {
         dep_node.extract_def_id(tcx).map(|def_id| tcx.with_opt_param(def_id))
     }
 }
+
 impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for ty::WithOptParam<LocalDefId> {
     #[inline]
     fn can_reconstruct_query_key() -> bool {

src/librustc_middle/query/mod.rs

@@ -89,15 +89,19 @@ rustc_queries! {
             desc { |tcx| "HIR owner items in `{}`", tcx.def_path_str(key.to_def_id()) }
         }
 
-        /// Computes the `DefId` of the corresponding const parameter of a const argument.
-        /// Returns `None` if `def_id` is not a const argument.
+        /// Computes the `DefId` of the corresponding const parameter in case the `key` is a
+        /// const argument and returns `None` otherwise.
         ///
         /// ```rust
         /// let a = foo::<7>();
         /// //            ^ Calling `const_param_of` for this argument,
         ///
         /// fn foo<const N: usize>()
         /// //           ^ returns this `DefId`.
+        ///
+        /// fn bar() {
+        /// // ^ While calling `const_param_of` for other bodies returns `None`.
+        /// }
         /// ```
         query const_param_of(key: DefId) -> Option<DefId> {
             cache_on_disk_if { key.is_local() }

src/librustc_middle/ty/mod.rs

@@ -1622,6 +1622,7 @@ impl<T: Ord> Ord for WithOptParam<T> {
 }
 
 impl<'tcx> TyCtxt<'tcx> {
+    #[inline(always)]
     pub fn with_opt_param<T: IntoQueryParam<DefId> + Copy>(self, did: T) -> WithOptParam<T> {
         WithOptParam { did, param_did: self.const_param_of(did) }
     }

src/librustc_middle/ty/structural_impls.rs

@@ -844,9 +844,7 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {
         Self {
             substs: self.substs.fold_with(folder),
             def: match self.def {
-                // We don't fold the param `DefId` here,
-                // as it should only be used for `type_of`.
-                Item(did, param_did) => Item(did.fold_with(folder), param_did),
+                Item(did, param_did) => Item(did.fold_with(folder), param_did.fold_with(folder)),
                 VtableShim(did) => VtableShim(did.fold_with(folder)),
                 ReifyShim(did) => ReifyShim(did.fold_with(folder)),
                 Intrinsic(did) => Intrinsic(did.fold_with(folder)),

src/librustc_typeck/collect/type_of.rs

@@ -17,6 +17,9 @@ use rustc_trait_selection::traits;
 use super::ItemCtxt;
 use super::{bad_placeholder_type, is_suggestable_infer_ty};
 
+/// Computes the relevant generic parameter for a potential generic const argument.
+///
+/// This should be called using the query `tcx.const_param_of`.
 pub(super) fn const_param_of(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
     use hir::*;
 
@@ -127,7 +130,7 @@ pub(super) fn const_param_of(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
                     .nth(arg_index)
                     .map(|param| param.def_id)
             }
-            _ => return None,
+            _ => None,
         }
     } else {
         None