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>>;
 

src/librustc_mir/interpret/intrinsics.rs

@@ -81,7 +81,7 @@ crate fn eval_nullary_intrinsic<'tcx>(
     })
 }
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'_, 'mir, 'tcx, M> {
     /// Returns `true` if emulation happened.
     pub fn emulate_intrinsic(
         &mut self,

src/librustc_mir/interpret/operand.rs

@@ -259,7 +259,7 @@ pub(super) fn from_known_layout<'tcx>(
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'_, 'mir, 'tcx, M> {
     /// Normalice `place.ptr` to a `Pointer` if this is a place and not a ZST.
     /// Can be helpful to avoid lots of `force_ptr` calls later, if this place is used a lot.
     #[inline]

src/librustc_mir/interpret/operator.rs

@@ -10,7 +10,7 @@ use syntax::ast::FloatTy;
 
 use super::{ImmTy, Immediate, InterpCx, Machine, 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> {
     /// Applies the binary operation `op` to the two operands and writes a tuple of the result
     /// and a boolean signifying the potential overflow to the destination.
     pub fn binop_with_overflow(
@@ -46,7 +46,7 @@ impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M>
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'_, 'mir, 'tcx, M> {
     fn binary_char_op(
         &self,
         bin_op: mir::BinOp,

src/librustc_mir/interpret/place.rs

@@ -247,7 +247,7 @@ impl<'tcx, Tag: ::std::fmt::Debug> PlaceTy<'tcx, Tag> {
 }
 
 // separating the pointer tag for `impl Trait`, see https://github.com/rust-lang/rust/issues/54385
-impl<'infcx, 'mir, 'tcx, Tag, M> InterpCx<'infcx, 'mir, 'tcx, M>
+impl<'mir, 'tcx, Tag, M> InterpCx<'_, 'mir, 'tcx, M>
 where
     // FIXME: Working around https://github.com/rust-lang/rust/issues/54385
     Tag: ::std::fmt::Debug + Copy + Eq + Hash + 'static,

src/librustc_mir/interpret/step.rs

@@ -29,7 +29,7 @@ fn binop_right_homogeneous(op: mir::BinOp) -> bool {
     }
 }
 
-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 run(&mut self) -> InterpResult<'tcx> {
         while self.step()? {}
         Ok(())

src/librustc_mir/interpret/terminator.rs

@@ -10,7 +10,7 @@ use super::{
     FnVal, ImmTy, InterpCx, InterpResult, MPlaceTy, Machine, OpTy, PlaceTy, StackPopCleanup,
 };
 
-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(super) fn eval_terminator(
         &mut self,
         terminator: &mir::Terminator<'tcx>,

src/librustc_mir/interpret/traits.rs

@@ -4,7 +4,7 @@ use rustc::mir::interpret::{InterpResult, Pointer, PointerArithmetic, Scalar};
 use rustc::ty::layout::{Align, HasDataLayout, LayoutOf, Size};
 use rustc::ty::{self, Instance, Ty, TypeFoldable};
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'_, 'mir, 'tcx, M> {
     /// Creates a dynamic vtable for the given type and vtable origin. This is used only for
     /// objects.
     ///

src/librustc_mir/interpret/validity.rs

@@ -663,7 +663,7 @@ impl<'rt, 'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> ValueVisitor<'infcx, 'mir,
     }
 }
 
-impl<'infcx, 'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'infcx, 'mir, 'tcx, M> {
+impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'_, 'mir, 'tcx, M> {
     /// This function checks the data at `op`. `op` is assumed to cover valid memory if it
     /// is an indirect operand.
     /// It will error if the bits at the destination do not match the ones described by the layout.

src/librustc_traits/resolve_vtable.rs

@@ -48,13 +48,13 @@ pub fn resolve_vtable<'tcx>(
             // Currently, we use a fulfillment context to completely resolve
             // all nested obligations. This is because they can inform the
             // inference of the impl's type parameters.
-            let mut vtable = selection.map(|predicate| {
+            let vtable = selection.map(|predicate| {
                 debug!("resolve_vtable: register_predicate_obligation {:?}", predicate);
                 fulfill_cx.register_predicate_obligation(&infcx, predicate);
             });
 
-            vtable = infcx.resolve_vars_if_possible(&vtable);
-            vtable = tcx.erase_regions(&vtable);
+            let vtable = infcx.resolve_vars_if_possible(&vtable);
+            let vtable = tcx.erase_regions(&vtable);
 
             info!("Cache miss: {:?} => {:?}", trait_ref, vtable);
             Ok(vtable)