Add docstrings, add def_id method to ConstEvalInput, and elide some lifetime parameters.

Author: skinnyBat

src/librustc/infer/canonical/mod.rs

@@ -267,6 +267,8 @@ impl<'tcx, R> Canonical<'tcx, QueryResponse<'tcx, R>> {
 }
 
 impl<'tcx, V: TypeFoldable<'tcx>> Canonical<'tcx, V> {
+    /// Construct a canonical `value` with an empty set of variables
+    /// in the `ROOT` universe.
     pub fn empty(value: V) -> Canonical<'tcx, V> {
         assert!(!value.has_local_value() && !value.has_placeholders());
         Canonical {

src/librustc/mir/interpret/mod.rs

@@ -117,6 +117,7 @@ pub use self::pointer::{CheckInAllocMsg, Pointer, PointerArithmetic};
 
 use crate::infer::canonical::Canonical;
 use crate::mir;
+use crate::traits::Reveal;
 use crate::ty::codec::TyDecoder;
 use crate::ty::layout::{self, Size};
 use crate::ty::subst::GenericArgKind;
@@ -148,8 +149,23 @@ pub struct GlobalId<'tcx> {
     pub promoted: Option<mir::Promoted>,
 }
 
+/// The input type for const eval queries. Const eval queries a given both the `ParamEnv` in which
+/// the constant is evaluated in and the identifier of the constant.
 pub type ConstEvalInput<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>>;
 
+impl ConstEvalInput<'_> {
+    /// The `DefId` of the constant that is being evaluated.
+    pub fn def_id(&self) -> DefId {
+        self.value.value.instance.def_id()
+    }
+
+    pub fn with_reveal_user_facing(&self) -> Self {
+        let mut new_input = self.clone();
+        new_input.value.param_env.reveal = Reveal::UserFacing;
+        new_input
+    }
+}
+
 #[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)]
 pub struct AllocId(pub u64);
 

src/librustc/mir/interpret/queries.rs

@@ -44,6 +44,7 @@ impl<'tcx> TyCtxt<'tcx> {
             .enter(|ref infcx| infcx.const_eval_resolve(param_env, def_id, substs, span))
     }
 
+    /// Evaluates the constant represented by the instance.
     pub fn const_eval_instance(
         self,
         param_env: ty::ParamEnv<'tcx>,
@@ -72,6 +73,10 @@ impl<'tcx> TyCtxt<'tcx> {
 }
 
 impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
+    /// Evaluates the constant represented by the instance.
+    ///
+    /// The given `ParamEnv` and `Instance` can contain inference variables from this inference
+    /// context.
     pub fn const_eval_instance(
         &self,
         param_env: ty::ParamEnv<'tcx>,
@@ -88,6 +93,18 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         }
     }
 
+    /// Resolves and evaluates a constant.
+    ///
+    /// The constant can be located on a trait like `<A as B>::C`, in which case the given
+    /// substitutions and environment are used to resolve the constant. Alternatively if the
+    /// constant has generic parameters in scope the substitutions are used to evaluate the value of
+    /// the constant. For example in `fn foo<T>() { let _ = [0; bar::<T>()]; }` the repeat count
+    /// constant `bar::<T>()` requires a substitution for `T`, if the substitution for `T` is still
+    /// too generic for the constant to be evaluated then `Err(ErrorHandled::TooGeneric)` is
+    /// returned.
+    ///
+    /// The given `ParamEnv` and `substs` can contain inference variables from this inference
+    /// context.
     pub fn const_eval_resolve(
         &self,
         param_env: ty::ParamEnv<'tcx>,

src/librustc/query/mod.rs

@@ -472,7 +472,7 @@ rustc_queries! {
             no_force
             desc { |tcx|
                 "const-evaluating `{}`",
-                tcx.def_path_str(key.value.value.instance.def.def_id())
+                tcx.def_path_str(key.def_id())
             }
         }
 
@@ -489,7 +489,7 @@ rustc_queries! {
             no_force
             desc { |tcx|
                 "const-evaluating + checking `{}`",
-                tcx.def_path_str(key.value.value.instance.def.def_id())
+                tcx.def_path_str(key.def_id())
             }
             cache_on_disk_if(_, opt_result) {
                 // Only store results without errors

src/librustc/traits/query/resolve_vtable.rs

@@ -4,6 +4,10 @@ use crate::traits::{ObligationCause, Vtable};
 use crate::ty;
 
 impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
+    /// Attempts to resolves the `Vtable` for a given trait within a `ParamEnv`.
+    ///
+    /// If it can't due to the result being ambiguous, or an error occurred during selection, `None`
+    /// is returned.
     pub fn resolve_vtable(
         &self,
         param_env: ty::ParamEnv<'tcx>,

src/librustc/ty/instance.rs

@@ -203,10 +203,6 @@ impl<'tcx> Instance<'tcx> {
     /// trying to resolve `Debug::fmt` applied to `T` will yield `None`, because we do not
     /// know what code ought to run. (Note that this setting is also affected by the
     /// `RevealMode` in the parameter environment.)
-    ///
-    /// Presuming that coherence and type-check have succeeded, if this method is invoked
-    /// in a monomorphic context (i.e., like during codegen), then it is guaranteed to return
-    /// `Some`.
     pub fn resolve<'infcx>(
         infcx: &'infcx InferCtxt<'infcx, 'tcx>,
         param_env: ty::ParamEnv<'tcx>,
@@ -255,6 +251,12 @@ impl<'tcx> Instance<'tcx> {
         result
     }
 
+    /// Resolves a `(def_id, substs)` pair to an instance within a monomorphic context
+    /// (i.e., like during codegen). This is most commonly used to find the precise code that
+    /// will run for a trait method invocation.
+    ///
+    /// This assumes that resolving the instance will be successful, so should only be used after
+    /// coherence and type-check have succeeded.
     pub fn resolve_mono(
         tcx: TyCtxt<'tcx>,
         def_id: DefId,

src/librustc_mir/const_eval/eval_queries.rs

@@ -167,12 +167,12 @@ fn validate_and_turn_into_const<'tcx>(
     constant: RawConst<'tcx>,
     key: ConstEvalInput<'tcx>,
 ) -> ::rustc::mir::interpret::ConstEvalResult<'tcx> {
-    let span = tcx.def_span(key.value.value.instance.def_id());
+    let def_id = key.def_id();
+    let span = tcx.def_span(def_id);
     tcx.infer_ctxt().enter_with_canonical(
         span,
         &key,
         |ref infcx, ty::ParamEnvAnd { param_env, value: cid }, _| {
-            let def_id = cid.instance.def.def_id();
             let is_static = tcx.is_static(def_id);
             let ecx = InterpCx::new(
                 tcx.at(span),
@@ -227,9 +227,7 @@ pub fn const_eval_validated_provider<'tcx>(
 
     // see comment in const_eval_raw_provider for what we're doing here
     if param_env.reveal == Reveal::All {
-        let mut key = key.clone();
-        key.value.param_env.reveal = Reveal::UserFacing;
-        match tcx.const_eval_validated(key) {
+        match tcx.const_eval_validated(key.with_reveal_user_facing()) {
             // try again with reveal all as requested
             Err(ErrorHandled::TooGeneric) => {}
             // dedupliate calls
@@ -270,9 +268,7 @@ pub fn const_eval_raw_provider<'tcx>(
 
     // In case we fail in the `UserFacing` variant, we just do the real computation.
     if param_env.reveal == Reveal::All {
-        let mut key = key.clone();
-        key.value.param_env.reveal = Reveal::UserFacing;
-        match tcx.const_eval_raw(key) {
+        match tcx.const_eval_raw(key.with_reveal_user_facing()) {
             // try again with reveal all as requested
             Err(ErrorHandled::TooGeneric) => {}
             // dedupliate calls
@@ -289,15 +285,15 @@ pub fn const_eval_raw_provider<'tcx>(
         trace!("const eval: {:?} ({})", key, instance);
     }
 
-    let def_id = cid.instance.def.def_id();
+    let def_id = key.def_id();
 
     if def_id.is_local() && tcx.typeck_tables_of(def_id).tainted_by_errors {
         return Err(ErrorHandled::Reported);
     }
 
     let is_static = tcx.is_static(def_id);
 
-    let span = tcx.def_span(cid.instance.def_id());
+    let span = tcx.def_span(def_id);
     tcx.infer_ctxt().enter_with_canonical(
         span,
         &key,

src/librustc_mir/const_eval/machine.rs

@@ -17,7 +17,7 @@ use crate::interpret::{
 
 use super::error::*;
 
-impl<'infcx, 'mir, 'tcx> InterpCx<'infcx, 'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
+impl<'mir, 'tcx> InterpCx<'_, 'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>> {
     /// Evaluate a const function where all arguments (if any) are zero-sized types.
     /// The evaluation is memoized thanks to the query system.
     ///

src/librustc_mir/interpret/cast.rs

@@ -11,7 +11,7 @@ use rustc_apfloat::{Float, FloatConvert};
 
 use super::{FnVal, ImmTy, Immediate, InterpCx, Machine, OpTy, PlaceTy};
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'_, 'mir, 'tcx, M> {
     pub fn cast(
         &mut self,
         src: OpTy<'tcx, M::PointerTag>,

src/librustc_mir/interpret/eval_context.rs

@@ -179,14 +179,14 @@ impl<'mir, 'tcx, Tag, Extra> Frame<'mir, 'tcx, Tag, Extra> {
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> HasDataLayout for InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> HasDataLayout for InterpCx<'_, 'mir, 'tcx, M> {
     #[inline]
     fn data_layout(&self) -> &layout::TargetDataLayout {
         &self.tcx.data_layout
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for InterpCx<'infcx, 'mir, 'tcx, M>
+impl<'mir, 'tcx, M> layout::HasTyCtxt<'tcx> for InterpCx<'_, 'mir, 'tcx, M>
 where
     M: Machine<'mir, 'tcx>,
 {
@@ -196,7 +196,7 @@ where
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M> layout::HasParamEnv<'tcx> for InterpCx<'infcx, 'mir, 'tcx, M>
+impl<'mir, 'tcx, M> layout::HasParamEnv<'tcx> for InterpCx<'_, 'mir, 'tcx, M>
 where
     M: Machine<'mir, 'tcx>,
 {
@@ -205,7 +205,7 @@ where
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> LayoutOf for InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> LayoutOf for InterpCx<'_, 'mir, 'tcx, M> {
     type Ty = Ty<'tcx>;
     type TyLayout = InterpResult<'tcx, TyLayout<'tcx>>;