diff options
Diffstat (limited to 'src/librustc')
| -rw-r--r-- | src/librustc/hir/mod.rs | 5 | ||||
| -rw-r--r-- | src/librustc/infer/canonical/canonicalizer.rs | 8 | ||||
| -rw-r--r-- | src/librustc/infer/error_reporting/mod.rs | 14 | ||||
| -rw-r--r-- | src/librustc/infer/outlives/obligations.rs | 2 | ||||
| -rw-r--r-- | src/librustc/mir/interpret/pointer.rs | 15 | ||||
| -rw-r--r-- | src/librustc/session/config.rs | 2 | ||||
| -rw-r--r-- | src/librustc/traits/auto_trait.rs | 170 | ||||
| -rw-r--r-- | src/librustc/traits/mod.rs | 35 | ||||
| -rw-r--r-- | src/librustc/traits/select.rs | 304 | ||||
| -rw-r--r-- | src/librustc/traits/util.rs | 2 | ||||
| -rw-r--r-- | src/librustc/ty/error.rs | 9 | ||||
| -rw-r--r-- | src/librustc/ty/instance.rs | 6 | ||||
| -rw-r--r-- | src/librustc/ty/layout.rs | 4 | ||||
| -rw-r--r-- | src/librustc/ty/mod.rs | 9 | ||||
| -rw-r--r-- | src/librustc/ty/relate.rs | 4 | ||||
| -rw-r--r-- | src/librustc/ty/structural_impls.rs | 3 | ||||
| -rw-r--r-- | src/librustc/ty/sty.rs | 81 | ||||
| -rw-r--r-- | src/librustc/ty/util.rs | 6 |
18 files changed, 344 insertions, 335 deletions
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 17b13dae37f..a2c4bdc5633 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -1919,8 +1919,9 @@ pub enum ImplItemKind { /// Bindings like `A: Debug` are represented as a special type `A = /// $::Debug` that is understood by the astconv code. /// -/// FIXME(alexreg) -- why have a separate type for the binding case, -/// wouldn't it be better to make the `ty` field an enum like: +/// FIXME(alexreg): why have a separate type for the binding case, +/// wouldn't it be better to make the `ty` field an enum like the +/// following? /// /// ``` /// enum TypeBindingKind { diff --git a/src/librustc/infer/canonical/canonicalizer.rs b/src/librustc/infer/canonical/canonicalizer.rs index e782ec59295..1fa814dc14e 100644 --- a/src/librustc/infer/canonical/canonicalizer.rs +++ b/src/librustc/infer/canonical/canonicalizer.rs @@ -306,7 +306,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> { match *r { ty::ReLateBound(index, ..) => { if index >= self.binder_index { - bug!("escaping late bound region during canonicalization") + bug!("escaping late-bound region during canonicalization"); } else { r } @@ -336,7 +336,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> { .canonicalize_free_region(self, r), ty::ReClosureBound(..) => { - bug!("closure bound region encountered during canonicalization") + bug!("closure bound region encountered during canonicalization"); } } } @@ -346,14 +346,14 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> { ty::Infer(ty::TyVar(vid)) => { debug!("canonical: type var found with vid {:?}", vid); match self.infcx.unwrap().probe_ty_var(vid) { - // `t` could be a float / int variable: canonicalize that instead + // `t` could be a float / int variable; canonicalize that instead. Ok(t) => { debug!("(resolved to {:?})", t); self.fold_ty(t) } // `TyVar(vid)` is unresolved, track its universe index in the canonicalized - // result + // result. Err(mut ui) => { if !self.infcx.unwrap().tcx.sess.opts.debugging_opts.chalk { // FIXME: perf problem described in #55921. diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index f2607b23527..0f93ef6b1a9 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -48,22 +48,24 @@ use super::lexical_region_resolve::RegionResolutionError; use super::region_constraints::GenericKind; use super::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TypeTrace, ValuePairs}; -use crate::infer::{self, SuppressRegionErrors}; use crate::hir; use crate::hir::def_id::DefId; use crate::hir::Node; +use crate::infer::{self, SuppressRegionErrors}; use crate::infer::opaque_types; use crate::middle::region; -use crate::traits::{IfExpressionCause, MatchExpressionArmCause, ObligationCause}; -use crate::traits::{ObligationCauseCode}; +use crate::traits::{ + IfExpressionCause, MatchExpressionArmCause, ObligationCause, ObligationCauseCode, +}; use crate::ty::error::TypeError; use crate::ty::{self, subst::{Subst, SubstsRef}, Region, Ty, TyCtxt, TypeFoldable}; + use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString}; -use std::{cmp, fmt}; +use rustc_error_codes::*; use syntax_pos::{Pos, Span}; -use rustc_error_codes::*; +use std::{cmp, fmt}; mod note; @@ -1270,7 +1272,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { } /// When encountering a case where `.as_ref()` on a `Result` or `Option` would be appropriate, - /// suggest it. + /// suggests it. fn suggest_as_ref_where_appropriate( &self, span: Span, diff --git a/src/librustc/infer/outlives/obligations.rs b/src/librustc/infer/outlives/obligations.rs index f7806188775..f9443376a93 100644 --- a/src/librustc/infer/outlives/obligations.rs +++ b/src/librustc/infer/outlives/obligations.rs @@ -221,7 +221,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> { } /// The `TypeOutlives` struct has the job of "lowering" a `T: 'a` -/// obligation into a series of `'a: 'b` constraints and "verifys", as +/// obligation into a series of `'a: 'b` constraints and "verify"s, as /// described on the module comment. The final constraints are emitted /// via a "delegate" of type `D` -- this is usually the `infcx`, which /// accrues them into the `region_obligations` code, but for NLL we diff --git a/src/librustc/mir/interpret/pointer.rs b/src/librustc/mir/interpret/pointer.rs index 7c77b2c0711..78320c769f6 100644 --- a/src/librustc/mir/interpret/pointer.rs +++ b/src/librustc/mir/interpret/pointer.rs @@ -1,11 +1,12 @@ -use std::fmt::{self, Display}; -use std::convert::TryFrom; +use super::{AllocId, InterpResult}; use crate::mir; use crate::ty::layout::{self, HasDataLayout, Size}; + use rustc_macros::HashStable; -use super::{AllocId, InterpResult}; +use std::convert::TryFrom; +use std::fmt::{self, Display}; /// Used by `check_in_alloc` to indicate context of check #[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)] @@ -74,8 +75,8 @@ pub trait PointerArithmetic: layout::HasDataLayout { fn overflowing_signed_offset(&self, val: u64, i: i128) -> (u64, bool) { // FIXME: is it possible to over/underflow here? if i < 0 { - // Trickery to ensure that i64::min_value() works fine: compute n = -i. - // This formula only works for true negative values, it overflows for zero! + // Trickery to ensure that `i64::min_value()` works fine: compute `n = -i`. + // This formula only works for true negative values; it overflows for zero! let n = u64::max_value() - (i as u64) + 1; let res = val.overflowing_sub(n); self.truncate_to_ptr(res) @@ -105,7 +106,7 @@ impl<T: layout::HasDataLayout> PointerArithmetic for T {} /// /// Defaults to the index based and loosely coupled `AllocId`. /// -/// Pointer is also generic over the `Tag` associated with each pointer, +/// `Pointer` is also generic over the `Tag` associated with each pointer, /// which is used to do provenance tracking during execution. #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, RustcEncodable, RustcDecodable, Hash, HashStable)] @@ -129,7 +130,7 @@ impl<Id: fmt::Debug> fmt::Debug for Pointer<(), Id> { } } -/// Produces a `Pointer` which points to the beginning of the `Allocation`. +/// Produces a `Pointer` that points to the beginning of the `Allocation`. impl From<AllocId> for Pointer { #[inline(always)] fn from(alloc_id: AllocId) -> Self { diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index b9b6a5f2342..50752bac30f 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1203,7 +1203,7 @@ options! {CodegenOptions, CodegenSetter, basic_codegen_options, force_frame_pointers: Option<bool> = (None, parse_opt_bool, [TRACKED], "force use of the frame pointers"), debug_assertions: Option<bool> = (None, parse_opt_bool, [TRACKED], - "explicitly enable the cfg(debug_assertions) directive"), + "explicitly enable the `cfg(debug_assertions)` directive"), inline_threshold: Option<usize> = (None, parse_opt_uint, [TRACKED], "set the threshold for inlining a function (default: 225)"), panic: Option<PanicStrategy> = (None, parse_panic_strategy, diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs index 9faf58aee6f..479bffc3ea0 100644 --- a/src/librustc/traits/auto_trait.rs +++ b/src/librustc/traits/auto_trait.rs @@ -1,18 +1,18 @@ -//! Support code for rustdoc and external tools . You really don't -//! want to be using this unless you need to. +//! Support code for rustdoc and external tools. +//! You really don't want to be using this unless you need to. use super::*; -use std::collections::hash_map::Entry; -use std::collections::VecDeque; - use crate::infer::region_constraints::{Constraint, RegionConstraintData}; use crate::infer::InferCtxt; -use rustc_data_structures::fx::{FxHashMap, FxHashSet}; - use crate::ty::fold::TypeFolder; use crate::ty::{Region, RegionVid}; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; + +use std::collections::hash_map::Entry; +use std::collections::VecDeque; + // FIXME(twk): this is obviously not nice to duplicate like that #[derive(Eq, PartialEq, Hash, Copy, Clone, Debug)] pub enum RegionTarget<'tcx> { @@ -233,43 +233,45 @@ impl<'tcx> AutoTraitFinder<'tcx> { } impl AutoTraitFinder<'tcx> { - // The core logic responsible for computing the bounds for our synthesized impl. - // - // To calculate the bounds, we call SelectionContext.select in a loop. Like FulfillmentContext, - // we recursively select the nested obligations of predicates we encounter. However, whenever we - // encounter an UnimplementedError involving a type parameter, we add it to our ParamEnv. Since - // our goal is to determine when a particular type implements an auto trait, Unimplemented - // errors tell us what conditions need to be met. - // - // This method ends up working somewhat similarly to FulfillmentContext, but with a few key - // differences. FulfillmentContext works under the assumption that it's dealing with concrete - // user code. According, it considers all possible ways that a Predicate could be met - which - // isn't always what we want for a synthesized impl. For example, given the predicate 'T: - // Iterator', FulfillmentContext can end up reporting an Unimplemented error for T: - // IntoIterator - since there's an implementation of Iteratpr where T: IntoIterator, - // FulfillmentContext will drive SelectionContext to consider that impl before giving up. If we - // were to rely on FulfillmentContext's decision, we might end up synthesizing an impl like - // this: - // 'impl<T> Send for Foo<T> where T: IntoIterator' - // - // While it might be technically true that Foo implements Send where T: IntoIterator, - // the bound is overly restrictive - it's really only necessary that T: Iterator. - // - // For this reason, evaluate_predicates handles predicates with type variables specially. When - // we encounter an Unimplemented error for a bound such as 'T: Iterator', we immediately add it - // to our ParamEnv, and add it to our stack for recursive evaluation. When we later select it, - // we'll pick up any nested bounds, without ever inferring that 'T: IntoIterator' needs to - // hold. - // - // One additional consideration is supertrait bounds. Normally, a ParamEnv is only ever - // constructed once for a given type. As part of the construction process, the ParamEnv will - // have any supertrait bounds normalized - e.g., if we have a type 'struct Foo<T: Copy>', the - // ParamEnv will contain 'T: Copy' and 'T: Clone', since 'Copy: Clone'. When we construct our - // own ParamEnv, we need to do this ourselves, through traits::elaborate_predicates, or else - // SelectionContext will choke on the missing predicates. However, this should never show up in - // the final synthesized generics: we don't want our generated docs page to contain something - // like 'T: Copy + Clone', as that's redundant. Therefore, we keep track of a separate - // 'user_env', which only holds the predicates that will actually be displayed to the user. + /// The core logic responsible for computing the bounds for our synthesized impl. + /// + /// To calculate the bounds, we call `SelectionContext.select` in a loop. Like + /// `FulfillmentContext`, we recursively select the nested obligations of predicates we + /// encounter. However, whenever we encounter an `UnimplementedError` involving a type + /// parameter, we add it to our `ParamEnv`. Since our goal is to determine when a particular + /// type implements an auto trait, Unimplemented errors tell us what conditions need to be met. + /// + /// This method ends up working somewhat similarly to `FulfillmentContext`, but with a few key + /// differences. `FulfillmentContext` works under the assumption that it's dealing with concrete + /// user code. According, it considers all possible ways that a `Predicate` could be met, which + /// isn't always what we want for a synthesized impl. For example, given the predicate `T: + /// Iterator`, `FulfillmentContext` can end up reporting an Unimplemented error for `T: + /// IntoIterator` -- since there's an implementation of `Iterator` where `T: IntoIterator`, + /// `FulfillmentContext` will drive `SelectionContext` to consider that impl before giving up. + /// If we were to rely on `FulfillmentContext`s decision, we might end up synthesizing an impl + /// like this: + /// + /// impl<T> Send for Foo<T> where T: IntoIterator + /// + /// While it might be technically true that Foo implements Send where `T: IntoIterator`, + /// the bound is overly restrictive - it's really only necessary that `T: Iterator`. + /// + /// For this reason, `evaluate_predicates` handles predicates with type variables specially. + /// When we encounter an `Unimplemented` error for a bound such as `T: Iterator`, we immediately + /// add it to our `ParamEnv`, and add it to our stack for recursive evaluation. When we later + /// select it, we'll pick up any nested bounds, without ever inferring that `T: IntoIterator` + /// needs to hold. + /// + /// One additional consideration is supertrait bounds. Normally, a `ParamEnv` is only ever + /// constructed once for a given type. As part of the construction process, the `ParamEnv` will + /// have any supertrait bounds normalized -- e.g., if we have a type `struct Foo<T: Copy>`, the + /// `ParamEnv` will contain `T: Copy` and `T: Clone`, since `Copy: Clone`. When we construct our + /// own `ParamEnv`, we need to do this ourselves, through `traits::elaborate_predicates`, or + /// else `SelectionContext` will choke on the missing predicates. However, this should never + /// show up in the final synthesized generics: we don't want our generated docs page to contain + /// something like `T: Copy + Clone`, as that's redundant. Therefore, we keep track of a + /// separate `user_env`, which only holds the predicates that will actually be displayed to the + /// user. fn evaluate_predicates( &self, infcx: &InferCtxt<'_, 'tcx>, @@ -307,7 +309,7 @@ impl AutoTraitFinder<'tcx> { continue; } - // Call infcx.resolve_vars_if_possible to see if we can + // Call `infcx.resolve_vars_if_possible` to see if we can // get rid of any inference variables. let obligation = infcx.resolve_vars_if_possible( &Obligation::new(dummy_cause.clone(), new_env, pred) @@ -316,14 +318,14 @@ impl AutoTraitFinder<'tcx> { match &result { &Ok(Some(ref vtable)) => { - // If we see an explicit negative impl (e.g., 'impl !Send for MyStruct'), + // If we see an explicit negative impl (e.g., `impl !Send for MyStruct`), // we immediately bail out, since it's impossible for us to continue. match vtable { Vtable::VtableImpl(VtableImplData { impl_def_id, .. }) => { - // Blame tidy for the weird bracket placement + // Blame 'tidy' for the weird bracket placement. if infcx.tcx.impl_polarity(*impl_def_id) == ty::ImplPolarity::Negative { - debug!("evaluate_nested_obligations: Found explicit negative impl\ + debug!("evaluate_nested_obligations: found explicit negative impl\ {:?}, bailing out", impl_def_id); return None; } @@ -356,7 +358,7 @@ impl AutoTraitFinder<'tcx> { predicates.push_back(pred); } else { debug!( - "evaluate_nested_obligations: Unimplemented found, bailing: \ + "evaluate_nested_obligations: `Unimplemented` found, bailing: \ {:?} {:?} {:?}", ty, pred, @@ -392,29 +394,29 @@ impl AutoTraitFinder<'tcx> { return Some((new_env, final_user_env)); } - // This method is designed to work around the following issue: - // When we compute auto trait bounds, we repeatedly call SelectionContext.select, - // progressively building a ParamEnv based on the results we get. - // However, our usage of SelectionContext differs from its normal use within the compiler, - // in that we capture and re-reprocess predicates from Unimplemented errors. - // - // This can lead to a corner case when dealing with region parameters. - // During our selection loop in evaluate_predicates, we might end up with - // two trait predicates that differ only in their region parameters: - // one containing a HRTB lifetime parameter, and one containing a 'normal' - // lifetime parameter. For example: - // - // T as MyTrait<'a> - // T as MyTrait<'static> - // - // If we put both of these predicates in our computed ParamEnv, we'll - // confuse SelectionContext, since it will (correctly) view both as being applicable. - // - // To solve this, we pick the 'more strict' lifetime bound - i.e., the HRTB - // Our end goal is to generate a user-visible description of the conditions - // under which a type implements an auto trait. A trait predicate involving - // a HRTB means that the type needs to work with any choice of lifetime, - // not just one specific lifetime (e.g., 'static). + /// This method is designed to work around the following issue: + /// When we compute auto trait bounds, we repeatedly call `SelectionContext.select`, + /// progressively building a `ParamEnv` based on the results we get. + /// However, our usage of `SelectionContext` differs from its normal use within the compiler, + /// in that we capture and re-reprocess predicates from `Unimplemented` errors. + /// + /// This can lead to a corner case when dealing with region parameters. + /// During our selection loop in `evaluate_predicates`, we might end up with + /// two trait predicates that differ only in their region parameters: + /// one containing a HRTB lifetime parameter, and one containing a 'normal' + /// lifetime parameter. For example: + /// + /// T as MyTrait<'a> + /// T as MyTrait<'static> + /// + /// If we put both of these predicates in our computed `ParamEnv`, we'll + /// confuse `SelectionContext`, since it will (correctly) view both as being applicable. + /// + /// To solve this, we pick the 'more strict' lifetime bound -- i.e., the HRTB + /// Our end goal is to generate a user-visible description of the conditions + /// under which a type implements an auto trait. A trait predicate involving + /// a HRTB means that the type needs to work with any choice of lifetime, + /// not just one specific lifetime (e.g., `'static`). fn add_user_pred<'c>( &self, user_computed_preds: &mut FxHashSet<ty::Predicate<'c>>, @@ -430,7 +432,7 @@ impl AutoTraitFinder<'tcx> { if !new_substs.types().eq(old_substs.types()) { // We can't compare lifetimes if the types are different, - // so skip checking old_pred + // so skip checking `old_pred`. return true; } @@ -438,8 +440,8 @@ impl AutoTraitFinder<'tcx> { new_substs.regions().zip(old_substs.regions()) { match (new_region, old_region) { - // If both predicates have an 'ReLateBound' (a HRTB) in the - // same spot, we do nothing + // If both predicates have an `ReLateBound` (a HRTB) in the + // same spot, we do nothing. ( ty::RegionKind::ReLateBound(_, _), ty::RegionKind::ReLateBound(_, _), @@ -463,13 +465,13 @@ impl AutoTraitFinder<'tcx> { // varaible). // // In both cases, we want to remove the old predicate, - // from user_computed_preds, and replace it with the new + // from `user_computed_preds`, and replace it with the new // one. Having both the old and the new - // predicate in a ParamEnv would confuse SelectionContext + // predicate in a `ParamEnv` would confuse `SelectionContext`. // // We're currently in the predicate passed to 'retain', - // so we return 'false' to remove the old predicate from - // user_computed_preds + // so we return `false` to remove the old predicate from + // `user_computed_preds`. return false; } (_, ty::RegionKind::ReLateBound(_, _)) | @@ -486,8 +488,8 @@ impl AutoTraitFinder<'tcx> { // predicate has some other type of region. // // We want to leave the old - // predicate in user_computed_preds, and skip adding - // new_pred to user_computed_params. + // predicate in `user_computed_preds`, and skip adding + // new_pred to `user_computed_params`. should_add_new = false }, _ => {} @@ -505,8 +507,8 @@ impl AutoTraitFinder<'tcx> { } } - // This is very similar to handle_lifetimes. However, instead of matching ty::Region's - // to each other, we match ty::RegionVid's to ty::Region's + /// This is very similar to `handle_lifetimes`. However, instead of matching `ty::Region`s + /// to each other, we match `ty::RegionVid`s to `ty::Region`s. fn map_vid_to_region<'cx>( &self, regions: &RegionConstraintData<'cx>, @@ -573,7 +575,7 @@ impl AutoTraitFinder<'tcx> { finished_map.insert(v1, r1); } (&RegionTarget::Region(_), &RegionTarget::RegionVid(_)) => { - // Do nothing - we don't care about regions that are smaller than vids + // Do nothing; we don't care about regions that are smaller than vids. } (&RegionTarget::RegionVid(_), &RegionTarget::RegionVid(_)) => { if let Entry::Occupied(v) = vid_map.entry(*smaller) { diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index 3aa355ce11a..d94e004db29 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -191,23 +191,23 @@ pub enum ObligationCauseCode<'tcx> { /// Obligation incurred due to a coercion. Coercion { source: Ty<'tcx>, target: Ty<'tcx> }, - // Various cases where expressions must be sized/copy/etc: - /// L = X implies that L is Sized + /// Various cases where expressions must be `Sized` / `Copy` / etc. + /// `L = X` implies that `L` is `Sized`. AssignmentLhsSized, - /// (x1, .., xn) must be Sized + /// `(x1, .., xn)` must be `Sized`. TupleInitializerSized, - /// S { ... } must be Sized + /// `S { ... }` must be `Sized`. StructInitializerSized, - /// Type of each variable must be Sized + /// Type of each variable must be `Sized`. VariableType(hir::HirId), - /// Argument type must be Sized + /// Argument type must be `Sized`. SizedArgumentType, - /// Return type must be Sized + /// Return type must be `Sized`. SizedReturnType, - /// Yield type must be Sized + /// Yield type must be `Sized`. SizedYieldType, - /// [T,..n] --> T must be Copy. If `true`, suggest `const_in_array_repeat_expressions` feature - /// flag. + /// `[T, ..n]` implies that `T` must be `Copy`. + /// If `true`, suggest `const_in_array_repeat_expressions` feature flag. RepeatVec(bool), /// Types of fields (other than the last, except for packed structs) in a struct must be sized. @@ -216,7 +216,7 @@ pub enum ObligationCauseCode<'tcx> { /// Constant expressions must be sized. ConstSized, - /// Static items must have `Sync` type + /// `static` items must have `Sync` type. SharedStatic, BuiltinDerivedObligation(DerivedObligationCause<'tcx>), @@ -602,7 +602,7 @@ pub enum Vtable<'tcx, N> { /// the impl's type parameters. /// /// The type parameter `N` indicates the type used for "nested -/// obligations" that are required by the impl. During type check, this +/// obligations" that are required by the impl. During type-check, this /// is `Obligation`, as one might expect. During codegen, however, this /// is `()`, because codegen only requires a shallow resolution of an /// impl, and nested obligations are satisfied later. @@ -1046,8 +1046,7 @@ fn vtable_methods<'tcx>( return None; } - // the method may have some early-bound lifetimes, add - // regions for those + // The method may have some early-bound lifetimes; add regions for those. let substs = trait_ref.map_bound(|trait_ref| InternalSubsts::for_item(tcx, def_id, |param, _| match param.kind { @@ -1060,15 +1059,15 @@ fn vtable_methods<'tcx>( ) ); - // the trait type may have higher-ranked lifetimes in it; - // so erase them if they appear, so that we get the type - // at some particular call site + // The trait type may have higher-ranked lifetimes in it; + // erase them if they appear, so that we get the type + // at some particular call site. let substs = tcx.normalize_erasing_late_bound_regions( ty::ParamEnv::reveal_all(), &substs ); - // It's possible that the method relies on where clauses that + // It's possible that the method relies on where-clauses that // do not hold for this particular set of type parameters. // Note that this method could then never be called, so we // do not want to try and codegen it, in that case (see #23435). diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index ffc94cf2b12..283fa56d11f 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -157,7 +157,7 @@ impl IntercrateAmbiguityCause { struct TraitObligationStack<'prev, 'tcx> { obligation: &'prev TraitObligation<'tcx>, - /// Trait ref from `obligation` but "freshened" with the + /// The trait ref from `obligation` but "freshened" with the /// selection-context's freshener. Used to check for recursion. fresh_trait_ref: ty::PolyTraitRef<'tcx>, @@ -193,11 +193,11 @@ struct TraitObligationStack<'prev, 'tcx> { previous: TraitObligationStackList<'prev, 'tcx>, - /// Number of parent frames plus one -- so the topmost frame has depth 1. + /// The number of parent frames plus one (thus, the topmost frame has depth 1). depth: usize, - /// Depth-first number of this node in the search graph -- a - /// pre-order index. Basically a freshly incremented counter. + /// The depth-first number of this node in the search graph -- a + /// pre-order index. Basically, a freshly incremented counter. dfn: usize, } @@ -239,9 +239,9 @@ pub struct SelectionCache<'tcx> { /// } /// fn foo<T: AsDebug>(t: T) { println!("{:?}", <T as AsDebug>::debug(t)); } /// -/// we can't just use the impl to resolve the <T as AsDebug> obligation -/// - a type from another crate (that doesn't implement fmt::Debug) could -/// implement AsDebug. +/// we can't just use the impl to resolve the `<T as AsDebug>` obligation +/// -- a type from another crate (that doesn't implement `fmt::Debug`) could +/// implement `AsDebug`. /// /// Because where-clauses match the type exactly, multiple clauses can /// only match if there are unresolved variables, and we can mostly just @@ -266,10 +266,10 @@ pub struct SelectionCache<'tcx> { /// } /// fn main() { foo(false); } /// -/// Here the obligation <T as Foo<$0>> can be matched by both the blanket -/// impl and the where-clause. We select the where-clause and unify $0=bool, +/// Here the obligation `<T as Foo<$0>>` can be matched by both the blanket +/// impl and the where-clause. We select the where-clause and unify `$0=bool`, /// so the program prints "false". However, if the where-clause is omitted, -/// the blanket impl is selected, we unify $0=(), and the program prints +/// the blanket impl is selected, we unify `$0=()`, and the program prints /// "()". /// /// Exactly the same issues apply to projection and object candidates, except @@ -282,8 +282,8 @@ pub struct SelectionCache<'tcx> { /// parameter environment. #[derive(PartialEq, Eq, Debug, Clone, TypeFoldable)] enum SelectionCandidate<'tcx> { - /// If has_nested is false, there are no *further* obligations BuiltinCandidate { + /// `false` if there are no *further* obligations. has_nested: bool, }, ParamCandidate(ty::PolyTraitRef<'tcx>), @@ -303,7 +303,7 @@ enum SelectionCandidate<'tcx> { GeneratorCandidate, /// Implementation of a `Fn`-family trait by one of the anonymous - /// types generated for a fn pointer type (e.g., `fn(int)->int`) + /// types generated for a fn pointer type (e.g., `fn(int) -> int`) FnPointerCandidate, TraitAliasCandidate(DefId), @@ -339,11 +339,11 @@ impl<'a, 'tcx> ty::Lift<'tcx> for SelectionCandidate<'a> { } struct SelectionCandidateSet<'tcx> { - // a list of candidates that definitely apply to the current + // A list of candidates that definitely apply to the current // obligation (meaning: types unify). vec: Vec<SelectionCandidate<'tcx>>, - // if this is true, then there were candidates that might or might + // If `true`, then there were candidates that might or might // not have applied, but we couldn't tell. This occurs when some // of the input types are type variables, in which case there are // various "builtin" rules that might or might not trigger. @@ -358,7 +358,7 @@ struct EvaluatedCandidate<'tcx> { /// When does the builtin impl for `T: Trait` apply? enum BuiltinImplConditions<'tcx> { - /// The impl is conditional on T1,T2,.. : Trait + /// The impl is conditional on `T1, T2, ...: Trait`. Where(ty::Binder<Vec<Ty<'tcx>>>), /// There is no built-in impl. There may be some other /// candidate (a where-clause or user-defined impl). @@ -381,15 +381,15 @@ enum BuiltinImplConditions<'tcx> { /// the categories it's easy to see that the unions are correct. #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, HashStable)] pub enum EvaluationResult { - /// Evaluation successful + /// Evaluation successful. EvaluatedToOk, - /// Evaluation successful, but there were unevaluated region obligations + /// Evaluation successful, but there were unevaluated region obligations. EvaluatedToOkModuloRegions, - /// Evaluation is known to be ambiguous - it *might* hold for some + /// Evaluation is known to be ambiguous -- it *might* hold for some /// assignment of inference variables, but it might not. /// - /// While this has the same meaning as `EvaluatedToUnknown` - we can't - /// know whether this obligation holds or not - it is the result we + /// While this has the same meaning as `EvaluatedToUnknown` -- we can't + /// know whether this obligation holds or not -- it is the result we /// would get with an empty stack, and therefore is cacheable. EvaluatedToAmbig, /// Evaluation failed because of recursion involving inference @@ -404,29 +404,29 @@ pub enum EvaluationResult { /// We know this branch can't be a part of a minimal proof-tree for /// the "root" of our cycle, because then we could cut out the recursion /// and maintain a valid proof tree. However, this does not mean - /// that all the obligations on this branch do not hold - it's possible + /// that all the obligations on this branch do not hold -- it's possible /// that we entered this branch "speculatively", and that there /// might be some other way to prove this obligation that does not - /// go through this cycle - so we can't cache this as a failure. + /// go through this cycle -- so we can't cache this as a failure. /// /// For example, suppose we have this: /// /// ```rust,ignore (pseudo-Rust) - /// pub trait Trait { fn xyz(); } - /// // This impl is "useless", but we can still have - /// // an `impl Trait for SomeUnsizedType` somewhere. - /// impl<T: Trait + Sized> Trait for T { fn xyz() {} } + /// pub trait Trait { fn xyz(); } + /// // This impl is "useless", but we can still have + /// // an `impl Trait for SomeUnsizedType` somewhere. + /// impl<T: Trait + Sized> Trait for T { fn xyz() {} } /// - /// pub fn foo<T: Trait + ?Sized>() { - /// <T as Trait>::xyz(); - /// } + /// pub fn foo<T: Trait + ?Sized>() { + /// <T as Trait>::xyz(); + /// } /// ``` /// /// When checking `foo`, we have to prove `T: Trait`. This basically /// translates into this: /// /// ```plain,ignore - /// (T: Trait + Sized →_\impl T: Trait), T: Trait ⊢ T: Trait + /// (T: Trait + Sized →_\impl T: Trait), T: Trait ⊢ T: Trait /// ``` /// /// When we try to prove it, we first go the first option, which @@ -594,7 +594,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // 1. If no applicable impl or parameter bound can be found. // 2. If the output type parameters in the obligation do not match // those specified by the impl/bound. For example, if the obligation - // is `Vec<Foo>:Iterable<Bar>`, but the impl specifies + // is `Vec<Foo>: Iterable<Bar>`, but the impl specifies // `impl<T> Iterable<T> for Vec<T>`, than an error would result. /// Attempts to satisfy the obligation. If successful, this will affect the surrounding @@ -723,10 +723,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { debug!("evaluate_predicate_recursively(previous_stack={:?}, obligation={:?})", previous_stack.head(), obligation); - // Previous_stack stores a TraitObligatiom, while 'obligation' is - // a PredicateObligation. These are distinct types, so we can't - // use any Option combinator method that would force them to be - // the same + // `previous_stack` stores a `TraitObligatiom`, while `obligation` is + // a `PredicateObligation`. These are distinct types, so we can't + // use any `Option` combinator method that would force them to be + // the same. match previous_stack.head() { Some(h) => self.check_recursion_limit(&obligation, h.obligation)?, None => self.check_recursion_limit(&obligation, &obligation)? @@ -740,7 +740,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } ty::Predicate::Subtype(ref p) => { - // does this code ever run? + // Does this code ever run? match self.infcx .subtype_predicate(&obligation.cause, obligation.param_env, p) { @@ -768,8 +768,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }, ty::Predicate::TypeOutlives(..) | ty::Predicate::RegionOutlives(..) => { - // we do not consider region relationships when - // evaluating trait matches + // We do not consider region relationships when evaluating trait matches. Ok(EvaluatedToOkModuloRegions) } @@ -953,7 +952,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { stack: &TraitObligationStack<'_, 'tcx>, ) -> Option<EvaluationResult> { if let Some(cycle_depth) = stack.iter() - .skip(1) // skip top-most frame + .skip(1) // Skip top-most frame. .find(|prev| stack.obligation.param_env == prev.obligation.param_env && stack.fresh_trait_ref == prev.fresh_trait_ref) .map(|stack| stack.depth) @@ -1030,8 +1029,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .skip_binder() .input_types() .any(|ty| ty.is_fresh()); - // this check was an imperfect workaround for a bug n the old - // intercrate mode, it should be removed when that goes away. + // This check was an imperfect workaround for a bug in the old + // intercrate mode; it should be removed when that goes away. if unbound_input_types && self.intercrate == Some(IntercrateMode::Issue43355) { debug!( "evaluate_stack({:?}) --> unbound argument, intercrate --> ambiguous", @@ -1083,7 +1082,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } /// For defaulted traits, we use a co-inductive strategy to solve, so - /// that recursion is ok. This routine returns true if the top of the + /// that recursion is ok. This routine returns `true` if the top of the /// stack (`cycle[0]`): /// /// - is a defaulted trait, @@ -1107,7 +1106,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { result } - /// Further evaluate `candidate` to decide whether all type parameters match and whether nested + /// Further evaluates `candidate` to decide whether all type parameters match and whether nested /// obligations are met. Returns whether `candidate` remains viable after this further /// scrutiny. fn evaluate_candidate<'o>( @@ -1199,26 +1198,26 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .insert(trait_ref, WithDepNode::new(dep_node, result)); } - // For various reasons, it's possible for a subobligation - // to have a *lower* recursion_depth than the obligation used to create it. - // Projection sub-obligations may be returned from the projection cache, - // which results in obligations with an 'old' recursion_depth. - // Additionally, methods like ty::wf::obligations and - // InferCtxt.subtype_predicate produce subobligations without - // taking in a 'parent' depth, causing the generated subobligations - // to have a recursion_depth of 0 - // - // To ensure that obligation_depth never decreasees, we force all subobligations - // to have at least the depth of the original obligation. + /// For various reasons, it's possible for a subobligation + /// to have a *lower* recursion_depth than the obligation used to create it. + /// Projection sub-obligations may be returned from the projection cache, + /// which results in obligations with an 'old' `recursion_depth`. + /// Additionally, methods like `ty::wf::obligations` and + /// `InferCtxt.subtype_predicate` produce subobligations without + /// taking in a 'parent' depth, causing the generated subobligations + /// to have a `recursion_depth` of `0`. + /// + /// To ensure that obligation_depth never decreasees, we force all subobligations + /// to have at least the depth of the original obligation. fn add_depth<T: 'cx, I: Iterator<Item = &'cx mut Obligation<'tcx, T>>>(&self, it: I, min_depth: usize) { it.for_each(|o| o.recursion_depth = cmp::max(min_depth, o.recursion_depth) + 1); } - // Check that the recursion limit has not been exceeded. - // - // The weird return type of this function allows it to be used with the 'try' (?) - // operator within certain functions + /// Checks that the recursion limit has not been exceeded. + /// + /// The weird return type of this function allows it to be used with the `try` (`?`) + /// operator within certain functions. fn check_recursion_limit<T: Display + TypeFoldable<'tcx>, V: Display + TypeFoldable<'tcx>>( &self, obligation: &Obligation<'tcx, T>, @@ -1256,7 +1255,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // not update) the cache. self.check_recursion_limit(&stack.obligation, &stack.obligation)?; - // Check the cache. Note that we freshen the trait-ref // separately rather than using `stack.fresh_trait_ref` -- // this is because we want the unbound variables to be @@ -1436,10 +1434,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // candidate set is *individually* applicable. Now we have to // figure out if they contain mutual incompatibilities. This // frequently arises if we have an unconstrained input type -- - // for example, we are looking for $0:Eq where $0 is some + // for example, we are looking for `$0: Eq` where `$0` is some // unconstrained type variable. In that case, we'll get a - // candidate which assumes $0 == int, one that assumes $0 == - // usize, etc. This spells an ambiguity. + // candidate which assumes $0 == int, one that assumes `$0 == + // usize`, etc. This spells an ambiguity. // If there is more than one candidate, first winnow them down // by considering extra conditions (nested obligations and so @@ -1453,8 +1451,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // and we were to see some code `foo.push_clone()` where `boo` // is a `Vec<Bar>` and `Bar` does not implement `Clone`. If // we were to winnow, we'd wind up with zero candidates. - // Instead, we select the right impl now but report `Bar does - // not implement Clone`. + // Instead, we select the right impl now but report "`Bar` does + // not implement `Clone`". if candidates.len() == 1 { return self.filter_negative_and_reservation_impls(candidates.pop().unwrap()); } @@ -1586,7 +1584,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // avoid us having to fear that coherence results "pollute" // the master cache. Since coherence executes pretty quickly, // it's not worth going to more trouble to increase the - // hit-rate I don't think. + // hit-rate, I don't think. if self.intercrate.is_some() { return false; } @@ -1617,13 +1615,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } /// Determines whether can we safely cache the result - /// of selecting an obligation. This is almost always 'true', - /// except when dealing with certain ParamCandidates. + /// of selecting an obligation. This is almost always `true`, + /// except when dealing with certain `ParamCandidate`s. /// - /// Ordinarily, a ParamCandidate will contain no inference variables, - /// since it was usually produced directly from a DefId. However, + /// Ordinarily, a `ParamCandidate` will contain no inference variables, + /// since it was usually produced directly from a `DefId`. However, /// certain cases (currently only librustdoc's blanket impl finder), - /// a ParamEnv may be explicitly constructed with inference types. + /// a `ParamEnv` may be explicitly constructed with inference types. /// When this is the case, we do *not* want to cache the resulting selection /// candidate. This is due to the fact that it might not always be possible /// to equate the obligation's trait ref and the candidate's trait ref, @@ -1631,7 +1629,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { /// /// Because of this, we always want to re-run the full selection /// process for our obligation the next time we see it, since - /// we might end up picking a different SelectionCandidate (or none at all) + /// we might end up picking a different `SelectionCandidate` (or none at all). fn can_cache_candidate(&self, result: &SelectionResult<'tcx, SelectionCandidate<'tcx>> ) -> bool { @@ -1662,15 +1660,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { if self.can_use_global_caches(param_env) { if let Err(Overflow) = candidate { - // Don't cache overflow globally; we only produce this - // in certain modes. + // Don't cache overflow globally; we only produce this in certain modes. } else if !trait_ref.has_local_value() { if !candidate.has_local_value() { debug!( "insert_candidate_cache(trait_ref={:?}, candidate={:?}) global", trait_ref, candidate, ); - // This may overwrite the cache with the same value + // This may overwrite the cache with the same value. tcx.selection_cache .hashmap .borrow_mut() @@ -1755,7 +1752,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } else { if lang_items.clone_trait() == Some(def_id) { // Same builtin conditions as `Copy`, i.e., every type which has builtin support - // for `Copy` also has builtin support for `Clone`, + tuples and arrays of `Clone` + // for `Copy` also has builtin support for `Clone`, and tuples/arrays of `Clone` // types have builtin support for `Clone`. let clone_conditions = self.copy_clone_conditions(obligation); self.assemble_builtin_bound_candidates(clone_conditions, &mut candidates)?; @@ -1786,7 +1783,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ) { debug!("assemble_candidates_for_projected_tys({:?})", obligation); - // before we go into the whole placeholder thing, just + // Before we go into the whole placeholder thing, just // quickly check if the self-type is a projection at all. match obligation.predicate.skip_binder().trait_ref.self_ty().kind { ty::Projection(_) | ty::Opaque(..) => {} @@ -1907,10 +1904,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.infcx.leak_check(false, placeholder_map, snapshot).is_ok() } - /// Given an obligation like `<SomeTrait for T>`, search the obligations that the caller + /// Given an obligation like `<SomeTrait for T>`, searches the obligations that the caller /// supplied to find out whether it is listed among them. /// - /// Never affects inference environment. + /// Never affects the inference environment. fn assemble_candidates_from_caller_bounds<'o>( &mut self, stack: &TraitObligationStack<'o, 'tcx>, @@ -2052,7 +2049,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(()) } - /// Implement one of the `Fn()` family for a fn pointer. + /// Implements one of the `Fn()` family for a fn pointer. fn assemble_fn_pointer_candidates( &mut self, obligation: &TraitObligation<'tcx>, @@ -2067,14 +2064,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { return Ok(()); } - // Okay to skip binder because what we are inspecting doesn't involve bound regions + // Okay to skip binder because what we are inspecting doesn't involve bound regions. let self_ty = *obligation.self_ty().skip_binder(); match self_ty.kind { ty::Infer(ty::TyVar(_)) => { debug!("assemble_fn_pointer_candidates: ambiguous self-type"); - candidates.ambiguous = true; // could wind up being a fn() type + candidates.ambiguous = true; // Could wind up being a fn() type. } - // provide an impl, but only for suitable `fn` pointers + // Provide an impl, but only for suitable `fn` pointers. ty::FnDef(..) | ty::FnPtr(_) => { if let ty::FnSig { unsafety: hir::Unsafety::Normal, @@ -2092,7 +2089,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(()) } - /// Search for impls that might apply to `obligation`. + /// Searches for impls that might apply to `obligation`. fn assemble_candidates_from_impls( &mut self, obligation: &TraitObligation<'tcx>, @@ -2160,7 +2157,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // this path. } ty::Infer(ty::TyVar(_)) => { - // the auto impl might apply, we don't know + // The auto impl might apply; we don't know. candidates.ambiguous = true; } ty::Generator(_, _, movability) @@ -2188,7 +2185,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(()) } - /// Search for impls that might apply to `obligation`. + /// Searches for impls that might apply to `obligation`. fn assemble_candidates_from_object_ty( &mut self, obligation: &TraitObligation<'tcx>, @@ -2226,7 +2223,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { return; } } else { - // Only auto-trait bounds exist. + // Only auto trait bounds exist. return; } } @@ -2247,7 +2244,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // we are looking for. Specifically, do not only check for the // correct trait, but also the correct type parameters. // For example, we may be trying to upcast `Foo` to `Bar<i32>`, - // but `Foo` is declared as `trait Foo : Bar<u32>`. + // but `Foo` is declared as `trait Foo: Bar<u32>`. let upcast_trait_refs = util::supertraits(self.tcx(), poly_trait_ref) .filter(|upcast_trait_ref| { self.infcx.probe(|_| { @@ -2267,7 +2264,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }) } - /// Search for unsizing that might apply to `obligation`. + /// Searches for unsizing that might apply to `obligation`. fn assemble_candidates_for_unsizing( &mut self, obligation: &TraitObligation<'tcx>, @@ -2311,11 +2308,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { (&ty::Dynamic(ref data_a, ..), &ty::Dynamic(ref data_b, ..)) => { // Upcasts permit two things: // - // 1. Dropping builtin bounds, e.g., `Foo+Send` to `Foo` - // 2. Tightening the region bound, e.g., `Foo+'a` to `Foo+'b` if `'a : 'b` + // 1. Dropping auto traits, e.g., `Foo + Send` to `Foo` + // 2. Tightening the region bound, e.g., `Foo + 'a` to `Foo + 'b` if `'a: 'b` // // Note that neither of these changes requires any - // change at runtime. Eventually this will be + // change at runtime. Eventually this will be // generalized. // // We always upcast when we can because of reason @@ -2326,11 +2323,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .all(|b| data_a.auto_traits().any(|a| a == b)) } - // T -> Trait. + // `T` -> `Trait` (_, &ty::Dynamic(..)) => true, - // Ambiguous handling is below T -> Trait, because inference - // variables can still implement Unsize<Trait> and nested + // Ambiguous handling is below `T` -> `Trait`, because inference + // variables can still implement `Unsize<Trait>` and nested // obligations will have the final say (likely deferred). (&ty::Infer(ty::TyVar(_)), _) | (_, &ty::Infer(ty::TyVar(_))) => { debug!("assemble_candidates_for_unsizing: ambiguous"); @@ -2338,15 +2335,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { false } - // [T; n] -> [T]. + // `[T; n]` -> `[T]` (&ty::Array(..), &ty::Slice(_)) => true, - // Struct<T> -> Struct<U>. + // `Struct<T>` -> `Struct<U>` (&ty::Adt(def_id_a, _), &ty::Adt(def_id_b, _)) if def_id_a.is_struct() => { def_id_a == def_id_b } - // (.., T) -> (.., U). + // `(.., T)` -> `(.., U)` (&ty::Tuple(tys_a), &ty::Tuple(tys_b)) => tys_a.len() == tys_b.len(), _ => false, @@ -2404,7 +2401,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { |cand: &ty::PolyTraitRef<'_>| cand.is_global() && !cand.has_late_bound_regions(); match other.candidate { - // Prefer BuiltinCandidate { has_nested: false } to anything else. + // Prefer `BuiltinCandidate { has_nested: false }` to anything else. // This is a fix for #53123 and prevents winnowing from accidentally extending the // lifetime of a variable. BuiltinCandidate { has_nested: false } => true, @@ -2415,7 +2412,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { when there are other valid candidates" ); } - // Prefer BuiltinCandidate { has_nested: false } to anything else. + // Prefer `BuiltinCandidate { has_nested: false }` to anything else. // This is a fix for #53123 and prevents winnowing from accidentally extending the // lifetime of a variable. BuiltinCandidate { has_nested: false } => false, @@ -2446,7 +2443,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { when there are other valid candidates" ); } - // Prefer BuiltinCandidate { has_nested: false } to anything else. + // Prefer `BuiltinCandidate { has_nested: false }` to anything else. // This is a fix for #53123 and prevents winnowing from accidentally extending the // lifetime of a variable. BuiltinCandidate { has_nested: false } => false, @@ -2468,7 +2465,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ImplCandidate(other_def) => { // See if we can toss out `victim` based on specialization. // This requires us to know *for sure* that the `other` impl applies - // i.e., EvaluatedToOk: + // i.e., `EvaluatedToOk`. if other.evaluation.must_apply_modulo_regions() { match victim.candidate { ImplCandidate(victim_def) => { @@ -2496,7 +2493,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match victim.candidate { ParamCandidate(ref cand) => { // Prefer these to a global where-clause bound - // (see issue #50825) + // (see issue #50825). is_global(cand) && other.evaluation.must_apply_modulo_regions() } _ => false, @@ -2754,7 +2751,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { types.skip_binder().to_vec() } - // for `PhantomData<T>`, we pass `T` + // For `PhantomData<T>`, we pass `T`. ty::Adt(def, substs) if def.is_phantom_data() => substs.types().collect(), ty::Adt(def, substs) => def.all_fields().map(|f| f.ty(self.tcx(), substs)).collect(), @@ -2894,11 +2891,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } BuiltinObjectCandidate => { - // This indicates something like `(Trait+Send) : - // Send`. In this case, we know that this holds - // because that's what the object type is telling us, - // and there's really no additional obligations to - // prove and no types in particular to unify etc. + // This indicates something like `Trait + Send: Send`. In this case, we know that + // this holds because that's what the object type is telling us, and there's really + // no additional obligations to prove and no types in particular to unify, etc. Ok(VtableParam(Vec::new())) } @@ -3152,7 +3147,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // We want to find the first supertrait in the list of // supertraits that we can unify with, and do that // unification. We know that there is exactly one in the list - // where we can unify because otherwise select would have + // where we can unify, because otherwise select would have // reported an ambiguity. (When we do find a match, also // record it for later.) let nonmatching = util::supertraits(tcx, poly_trait_ref).take_while( @@ -3166,7 +3161,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }, ); - // Additionally, for each of the nonmatching predicates that + // Additionally, for each of the non-matching predicates that // we pass over, we sum up the set of number of vtable // entries, so that we can compute the offset for the selected // trait. @@ -3354,7 +3349,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { trait_ref, )?); - // FIXME: chalk + // FIXME: Chalk if !self.tcx().sess.opts.debugging_opts.chalk { obligations.push(Obligation::new( @@ -3421,7 +3416,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ) -> Result<VtableBuiltinData<PredicateObligation<'tcx>>, SelectionError<'tcx>> { let tcx = self.tcx(); - // assemble_candidates_for_unsizing should ensure there are no late bound + // `assemble_candidates_for_unsizing` should ensure there are no late-bound // regions here. See the comment there for more details. let source = self.infcx .shallow_resolve(obligation.self_ty().no_bound_vars().unwrap()); @@ -3442,20 +3437,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match (&source.kind, &target.kind) { // Trait+Kx+'a -> Trait+Ky+'b (upcasts). (&ty::Dynamic(ref data_a, r_a), &ty::Dynamic(ref data_b, r_b)) => { - // See assemble_candidates_for_unsizing for more info. + // See `assemble_candidates_for_unsizing` for more info. let existential_predicates = data_a.map_bound(|data_a| { let iter = data_a.principal().map(|x| ty::ExistentialPredicate::Trait(x)) - .into_iter().chain( - data_a - .projection_bounds() - .map(|x| ty::ExistentialPredicate::Projection(x)), - ) - .chain( - data_b - .auto_traits() - .map(ty::ExistentialPredicate::AutoTrait), - ); + .into_iter().chain( + data_a + .projection_bounds() + .map(|x| ty::ExistentialPredicate::Projection(x)), + ) + .chain( + data_b + .auto_traits() + .map(ty::ExistentialPredicate::AutoTrait), + ); tcx.mk_existential_predicates(iter) }); let source_trait = tcx.mk_dynamic(existential_predicates, r_b); @@ -3463,20 +3458,19 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // Require that the traits involved in this upcast are **equal**; // only the **lifetime bound** is changed. // - // FIXME: This condition is arguably too strong -- it - // would suffice for the source trait to be a - // *subtype* of the target trait. In particular - // changing from something like `for<'a, 'b> Foo<'a, - // 'b>` to `for<'a> Foo<'a, 'a>` should be + // FIXME: This condition is arguably too strong -- it would + // suffice for the source trait to be a *subtype* of the target + // trait. In particular, changing from something like + // `for<'a, 'b> Foo<'a, 'b>` to `for<'a> Foo<'a, 'a>` should be // permitted. And, indeed, in the in commit // 904a0bde93f0348f69914ee90b1f8b6e4e0d7cbc, this - // condition was loosened. However, when the leak check was added - // back, using subtype here actually guies the coercion code in - // such a way that it accepts `old-lub-glb-object.rs`. This is probably - // a good thing, but I've modified this to `.eq` because I want - // to continue rejecting that test (as we have done for quite some time) - // before we are firmly comfortable with what our behavior - // should be there. -nikomatsakis + // condition was loosened. However, when the leak check was + // added back, using subtype here actually guides the coercion + // code in such a way that it accepts `old-lub-glb-object.rs`. + // This is probably a good thing, but I've modified this to `.eq` + // because I want to continue rejecting that test (as we have + // done for quite some time) before we are firmly comfortable + // with what our behavior should be there. -nikomatsakis let InferOk { obligations, .. } = self.infcx .at(&obligation.cause, obligation.param_env) .eq(target, source_trait) // FIXME -- see below @@ -3498,7 +3492,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { )); } - // T -> Trait. + // `T` -> `Trait` (_, &ty::Dynamic(ref data, r)) => { let mut object_dids = data.auto_traits() .chain(data.principal_def_id()); @@ -3522,32 +3516,34 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }; // Create obligations: - // - Casting T to Trait + // - Casting `T` to `Trait` // - For all the various builtin bounds attached to the object cast. (In other - // words, if the object type is Foo+Send, this would create an obligation for the - // Send check.) + // words, if the object type is `Foo + Send`, this would create an obligation for + // the `Send` check.) // - Projection predicates nested.extend( data.iter() - .map(|d| predicate_to_obligation(d.with_self_ty(tcx, source))), + .map(|predicate| + predicate_to_obligation(predicate.with_self_ty(tcx, source)) + ), ); // We can only make objects from sized types. - let tr = ty::TraitRef { - def_id: tcx.require_lang_item(lang_items::SizedTraitLangItem, None), - substs: tcx.mk_substs_trait(source, &[]), - }; + let tr = ty::TraitRef::new( + tcx.require_lang_item(lang_items::SizedTraitLangItem, None), + tcx.mk_substs_trait(source, &[]), + ); nested.push(predicate_to_obligation(tr.to_predicate())); - // If the type is `Foo+'a`, ensures that the type - // being cast to `Foo+'a` outlives `'a`: + // If the type is `Foo + 'a`, ensure that the type + // being cast to `Foo + 'a` outlives `'a`: let outlives = ty::OutlivesPredicate(source, r); nested.push(predicate_to_obligation( ty::Binder::dummy(outlives).to_predicate(), )); } - // [T; n] -> [T]. + // `[T; n]` -> `[T]` (&ty::Array(a, _), &ty::Slice(b)) => { let InferOk { obligations, .. } = self.infcx .at(&obligation.cause, obligation.param_env) @@ -3556,10 +3552,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { nested.extend(obligations); } - // Struct<T> -> Struct<U>. + // `Struct<T>` -> `Struct<U>` (&ty::Adt(def, substs_a), &ty::Adt(_, substs_b)) => { let fields = def.all_fields() - .map(|f| tcx.type_of(f.did)) + .map(|field| tcx.type_of(field.did)) .collect::<Vec<_>>(); // The last field of the structure has to exist and contain type parameters. @@ -3598,7 +3594,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - // Extract Field<T> and Field<U> from Struct<T> and Struct<U>. + // Extract `Field<T>` and `Field<U>` from `Struct<T>` and `Struct<U>`. let inner_source = field.subst(tcx, substs_a); let inner_target = field.subst(tcx, substs_b); @@ -3618,7 +3614,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .map_err(|_| Unimplemented)?; nested.extend(obligations); - // Construct the nested Field<T>: Unsize<Field<U>> predicate. + // Construct the nested `Field<T>: Unsize<Field<U>>` predicate. nested.push(tcx.predicate_for_trait_def( obligation.param_env, obligation.cause.clone(), @@ -3629,7 +3625,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { )); } - // (.., T) -> (.., U). + // `(.., T)` -> `(.., U)` (&ty::Tuple(tys_a), &ty::Tuple(tys_b)) => { assert_eq!(tys_a.len(), tys_b.len()); @@ -3652,7 +3648,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .map_err(|_| Unimplemented)?; nested.extend(obligations); - // Construct the nested T: Unsize<U> predicate. + // Construct the nested `T: Unsize<U>` predicate. nested.push(tcx.predicate_for_trait_def( obligation.param_env, obligation.cause.clone(), @@ -3969,7 +3965,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // // This code is hot enough that it's worth avoiding the allocation // required for the FxHashSet when possible. Special-casing lengths 0, - // 1 and 2 covers roughly 75--80% of the cases. + // 1 and 2 covers roughly 75-80% of the cases. if predicates.len() <= 1 { // No possibility of duplicates. } else if predicates.len() == 2 { diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index d8b1effe09b..c15915a9d56 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -80,7 +80,7 @@ impl<T: AsRef<ty::Predicate<'tcx>>> Extend<T> for PredicateSet<'tcx> { /////////////////////////////////////////////////////////////////////////// /// "Elaboration" is the process of identifying all the predicates that -/// are implied by a source predicate. Currently this basically means +/// are implied by a source predicate. Currently, this basically means /// walking the "supertraits" and other similar assumptions. For example, /// if we know that `T: Ord`, the elaborator would deduce that `T: PartialOrd` /// holds as well. Similarly, if we have `trait Foo: 'static`, and we know that diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs index 8e3ae0864aa..be6d21564a0 100644 --- a/src/librustc/ty/error.rs +++ b/src/librustc/ty/error.rs @@ -1,14 +1,15 @@ +use crate::hir; use crate::hir::def_id::DefId; use crate::ty::{self, BoundRegion, Region, Ty, TyCtxt}; -use std::borrow::Cow; -use std::fmt; + +use errors::{Applicability, DiagnosticBuilder}; use rustc_target::spec::abi; use syntax::ast; use syntax::errors::pluralize; -use errors::{Applicability, DiagnosticBuilder}; use syntax_pos::Span; -use crate::hir; +use std::borrow::Cow; +use std::fmt; #[derive(Clone, Copy, Debug, PartialEq, Eq, TypeFoldable)] pub struct ExpectedFound<T> { diff --git a/src/librustc/ty/instance.rs b/src/librustc/ty/instance.rs index 7eee0a5e2b5..777db38850f 100644 --- a/src/librustc/ty/instance.rs +++ b/src/librustc/ty/instance.rs @@ -36,10 +36,10 @@ pub enum InstanceDef<'tcx> { ReifyShim(DefId), /// `<fn() as FnTrait>::call_*` - /// `DefId` is `FnTrait::call_*` + /// `DefId` is `FnTrait::call_*`. FnPtrShim(DefId, Ty<'tcx>), - /// `<Trait as Trait>::fn` + /// `<dyn Trait as Trait>::fn` Virtual(DefId, usize), /// `<[mut closure] as FnOnce>::call_once` @@ -115,7 +115,7 @@ impl<'tcx> Instance<'tcx> { pub fn fn_sig(&self, tcx: TyCtxt<'tcx>) -> ty::PolyFnSig<'tcx> { let mut fn_sig = self.fn_sig_noadjust(tcx); if let InstanceDef::VtableShim(..) = self.def { - // Modify fn(self, ...) to fn(self: *mut Self, ...) + // Modify `fn(self, ...)` to `fn(self: *mut Self, ...)`. fn_sig = fn_sig.map_bound(|mut fn_sig| { let mut inputs_and_output = fn_sig.inputs_and_output.to_vec(); inputs_and_output[0] = tcx.mk_mut_ptr(inputs_and_output[0]); diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index b9fc5f59b7b..37d1e8e3340 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -2103,8 +2103,8 @@ where ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => { assert!(i < this.fields.count()); - // Reuse the fat *T type as its own thin pointer data field. - // This provides information about e.g., DST struct pointees + // Reuse the fat `*T` type as its own thin pointer data field. + // This provides information about, e.g., DST struct pointees // (which may have no non-DST form), and will work as long // as the `Abi` or `FieldPlacement` is checked by users. if i == 0 { diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index d001916aca2..8ccfc467f4a 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -1923,17 +1923,17 @@ pub struct FieldDef { /// /// These are all interned (by `intern_adt_def`) into the `adt_defs` table. /// -/// The initialism *"Adt"* stands for an [*algebraic data type (ADT)*][adt]. +/// The initialism *ADT* stands for an [*algebraic data type (ADT)*][adt]. /// This is slightly wrong because `union`s are not ADTs. /// Moreover, Rust only allows recursive data types through indirection. /// /// [adt]: https://en.wikipedia.org/wiki/Algebraic_data_type pub struct AdtDef { - /// `DefId` of the struct, enum or union item. + /// The `DefId` of the struct, enum or union item. pub did: DefId, /// Variants of the ADT. If this is a struct or union, then there will be a single variant. pub variants: IndexVec<self::layout::VariantIdx, VariantDef>, - /// Flags of the ADT (e.g. is this a struct? is this non-exhaustive?) + /// Flags of the ADT (e.g., is this a struct? is this non-exhaustive?). flags: AdtFlags, /// Repr options provided by the user. pub repr: ReprOptions, @@ -1954,7 +1954,7 @@ impl Ord for AdtDef { } impl PartialEq for AdtDef { - // AdtDef are always interned and this is part of TyS equality + // `AdtDef`s are always interned, and this is part of `TyS` equality. #[inline] fn eq(&self, other: &Self) -> bool { ptr::eq(self, other) } } @@ -1976,7 +1976,6 @@ impl<'tcx> rustc_serialize::UseSpecializedEncodable for &'tcx AdtDef { impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx AdtDef {} - impl<'a> HashStable<StableHashingContext<'a>> for AdtDef { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { thread_local! { diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs index 369d0ee4d5b..efdf40fd6b8 100644 --- a/src/librustc/ty/relate.rs +++ b/src/librustc/ty/relate.rs @@ -281,7 +281,7 @@ impl<'tcx> Relate<'tcx> for ty::TraitRef<'tcx> { a: &ty::TraitRef<'tcx>, b: &ty::TraitRef<'tcx>, ) -> RelateResult<'tcx, ty::TraitRef<'tcx>> { - // Different traits cannot be related + // Different traits cannot be related. if a.def_id != b.def_id { Err(TypeError::Traits(expected_found(relation, &a.def_id, &b.def_id))) } else { @@ -297,7 +297,7 @@ impl<'tcx> Relate<'tcx> for ty::ExistentialTraitRef<'tcx> { a: &ty::ExistentialTraitRef<'tcx>, b: &ty::ExistentialTraitRef<'tcx>, ) -> RelateResult<'tcx, ty::ExistentialTraitRef<'tcx>> { - // Different traits cannot be related + // Different traits cannot be related. if a.def_id != b.def_id { Err(TypeError::Traits(expected_found(relation, &a.def_id, &b.def_id))) } else { diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 8fbd2e4e6b1..a0e66d340ae 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -4,12 +4,13 @@ use crate::hir::def::Namespace; use crate::mir::ProjectionKind; +use crate::mir::interpret; use crate::ty::{self, Lift, Ty, TyCtxt, InferConst}; use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use crate::ty::print::{FmtPrinter, Printer}; + use rustc_index::vec::{IndexVec, Idx}; use smallvec::SmallVec; -use crate::mir::interpret; use std::fmt; use std::rc::Rc; diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index ab6a3bc83b1..b72468a6ff9 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -2,14 +2,14 @@ #![allow(rustc::usage_of_ty_tykind)] +use self::InferTy::*; +use self::TyKind::*; + use crate::hir; use crate::hir::def_id::DefId; use crate::infer::canonical::Canonical; use crate::mir::interpret::ConstValue; use crate::middle::region; -use polonius_engine::Atom; -use rustc_index::vec::Idx; -use rustc_macros::HashStable; use crate::ty::subst::{InternalSubsts, Subst, SubstsRef, GenericArg, GenericArgKind}; use crate::ty::{self, AdtDef, Discr, DefIdTree, TypeFlags, Ty, TyCtxt, TypeFoldable}; use crate::ty::{List, TyS, ParamEnvAnd, ParamEnv}; @@ -17,27 +17,30 @@ use crate::ty::layout::VariantIdx; use crate::util::captures::Captures; use crate::mir::interpret::{Scalar, GlobalId}; +use polonius_engine::Atom; +use rustc_index::vec::Idx; +use rustc_macros::HashStable; +use rustc_target::spec::abi; use smallvec::SmallVec; use std::borrow::Cow; use std::cmp::Ordering; use std::marker::PhantomData; use std::ops::Range; -use rustc_target::spec::abi; use syntax::ast::{self, Ident}; use syntax::symbol::{kw, Symbol}; -use self::InferTy::*; -use self::TyKind::*; - -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] -#[derive(HashStable, TypeFoldable, Lift)] +#[derive( + Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable, + HashStable, TypeFoldable, Lift, +)] pub struct TypeAndMut<'tcx> { pub ty: Ty<'tcx>, pub mutbl: hir::Mutability, } -#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, - RustcEncodable, RustcDecodable, Copy, HashStable)] +#[derive( + Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Copy, HashStable, +)] /// A "free" region `fr` can be interpreted as "some region /// at least as big as the scope `fr.scope`". pub struct FreeRegion { @@ -45,8 +48,9 @@ pub struct FreeRegion { pub bound_region: BoundRegion, } -#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, - RustcEncodable, RustcDecodable, Copy, HashStable)] +#[derive( + Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Copy, HashStable, +)] pub enum BoundRegion { /// An anonymous region parameter for a given fn (&T) BrAnon(u32), @@ -471,18 +475,18 @@ impl<'tcx> GeneratorSubsts<'tcx> { } impl<'tcx> GeneratorSubsts<'tcx> { - /// Generator have not been resumed yet + /// Generator has not been resumed yet. pub const UNRESUMED: usize = 0; - /// Generator has returned / is completed + /// Generator has returned or is completed. pub const RETURNED: usize = 1; - /// Generator has been poisoned + /// Generator has been poisoned. pub const POISONED: usize = 2; const UNRESUMED_NAME: &'static str = "Unresumed"; const RETURNED_NAME: &'static str = "Returned"; const POISONED_NAME: &'static str = "Panicked"; - /// The valid variant indices of this Generator. + /// The valid variant indices of this generator. #[inline] pub fn variant_range(&self, def_id: DefId, tcx: TyCtxt<'tcx>) -> Range<VariantIdx> { // FIXME requires optimized MIR @@ -490,7 +494,7 @@ impl<'tcx> GeneratorSubsts<'tcx> { (VariantIdx::new(0)..VariantIdx::new(num_variants)) } - /// The discriminant for the given variant. Panics if the variant_index is + /// The discriminant for the given variant. Panics if the `variant_index` is /// out of range. #[inline] pub fn discriminant_for_variant( @@ -505,7 +509,7 @@ impl<'tcx> GeneratorSubsts<'tcx> { Discr { val: variant_index.as_usize() as u128, ty: self.discr_ty(tcx) } } - /// The set of all discriminants for the Generator, enumerated with their + /// The set of all discriminants for the generator, enumerated with their /// variant indices. #[inline] pub fn discriminants( @@ -670,12 +674,12 @@ impl<'tcx> List<ExistentialPredicate<'tcx>> { pub fn principal(&self) -> Option<ExistentialTraitRef<'tcx>> { match self[0] { ExistentialPredicate::Trait(tr) => Some(tr), - _ => None + _ => None, } } pub fn principal_def_id(&self) -> Option<DefId> { - self.principal().map(|d| d.def_id) + self.principal().map(|trait_ref| trait_ref.def_id) } #[inline] @@ -684,7 +688,7 @@ impl<'tcx> List<ExistentialPredicate<'tcx>> { { self.iter().filter_map(|predicate| { match *predicate { - ExistentialPredicate::Projection(p) => Some(p), + ExistentialPredicate::Projection(projection) => Some(projection), _ => None, } }) @@ -694,8 +698,8 @@ impl<'tcx> List<ExistentialPredicate<'tcx>> { pub fn auto_traits<'a>(&'a self) -> impl Iterator<Item = DefId> + 'a { self.iter().filter_map(|predicate| { match *predicate { - ExistentialPredicate::AutoTrait(d) => Some(d), - _ => None + ExistentialPredicate::AutoTrait(did) => Some(did), + _ => None, } }) } @@ -722,7 +726,8 @@ impl<'tcx> Binder<&'tcx List<ExistentialPredicate<'tcx>>> { } pub fn iter<'a>(&'a self) - -> impl DoubleEndedIterator<Item = Binder<ExistentialPredicate<'tcx>>> + 'tcx { + -> impl DoubleEndedIterator<Item = Binder<ExistentialPredicate<'tcx>>> + 'tcx + { self.skip_binder().iter().cloned().map(Binder::bind) } } @@ -751,7 +756,7 @@ pub struct TraitRef<'tcx> { impl<'tcx> TraitRef<'tcx> { pub fn new(def_id: DefId, substs: SubstsRef<'tcx>) -> TraitRef<'tcx> { - TraitRef { def_id: def_id, substs: substs } + TraitRef { def_id, substs } } /// Returns a `TraitRef` of the form `P0: Foo<P1..Pn>` where `Pi` @@ -822,7 +827,7 @@ pub struct ExistentialTraitRef<'tcx> { } impl<'tcx> ExistentialTraitRef<'tcx> { - pub fn input_types<'b>(&'b self) -> impl DoubleEndedIterator<Item=Ty<'tcx>> + 'b { + pub fn input_types<'b>(&'b self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> + 'b { // Select only the "input types" from a trait-reference. For // now this is all the types that appear in the // trait-reference, but it should eventually exclude @@ -1296,7 +1301,7 @@ pub enum RegionKind { /// A region variable. Should not exist after typeck. ReVar(RegionVid), - /// A placeholder region - basically the higher-ranked version of ReFree. + /// A placeholder region -- basically, the higher-ranked version of `ReFree`. /// Should not exist after typeck. RePlaceholder(ty::PlaceholderRegion), @@ -1807,14 +1812,14 @@ impl<'tcx> TyS<'tcx> { match self.kind { Array(ty, _) | Slice(ty) => ty, Str => tcx.mk_mach_uint(ast::UintTy::U8), - _ => bug!("sequence_element_type called on non-sequence value: {}", self), + _ => bug!("`sequence_element_type` called on non-sequence value: {}", self), } } pub fn simd_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { match self.kind { Adt(def, substs) => def.non_enum_variant().fields[0].ty(tcx, substs), - _ => bug!("simd_type called on invalid type") + _ => bug!("`simd_type` called on invalid type"), } } @@ -1823,7 +1828,7 @@ impl<'tcx> TyS<'tcx> { // allow `#[repr(simd)] struct Simd<T, const N: usize>([T; N]);`. match self.kind { Adt(def, _) => def.non_enum_variant().fields.len() as u64, - _ => bug!("simd_size called on invalid type") + _ => bug!("`simd_size` called on invalid type"), } } @@ -1833,7 +1838,7 @@ impl<'tcx> TyS<'tcx> { let variant = def.non_enum_variant(); (variant.fields.len() as u64, variant.fields[0].ty(tcx, substs)) } - _ => bug!("simd_size_and_type called on invalid type") + _ => bug!("`simd_size_and_type` called on invalid type"), } } @@ -1894,7 +1899,7 @@ impl<'tcx> TyS<'tcx> { } } - /// panics if called on any type other than `Box<T>` + /// Panics if called on any type other than `Box<T>`. pub fn boxed_ty(&self) -> Ty<'tcx> { match self.kind { Adt(def, substs) if def.is_box() => substs.type_at(0), @@ -2114,7 +2119,8 @@ impl<'tcx> TyS<'tcx> { } /// If the type contains variants, returns the valid range of variant indices. - /// FIXME This requires the optimized MIR in the case of generators. + // + // FIXME: This requires the optimized MIR in the case of generators. #[inline] pub fn variant_range(&self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>> { match self.kind { @@ -2127,7 +2133,8 @@ impl<'tcx> TyS<'tcx> { /// If the type contains variants, returns the variant for `variant_index`. /// Panics if `variant_index` is out of range. - /// FIXME This requires the optimized MIR in the case of generators. + // + // FIXME: This requires the optimized MIR in the case of generators. #[inline] pub fn discriminant_for_variant( &self, @@ -2142,7 +2149,7 @@ impl<'tcx> TyS<'tcx> { } } - /// Push onto `out` the regions directly referenced from this type (but not + /// Pushes onto `out` the regions directly referenced from this type (but not /// types reachable from this type via `walk_tys`). This ignores late-bound /// regions binders. pub fn push_regions(&self, out: &mut SmallVec<[ty::Region<'tcx>; 4]>) { @@ -2255,7 +2262,7 @@ impl<'tcx> TyS<'tcx> { ty::Infer(ty::FreshTy(_)) | ty::Infer(ty::FreshIntTy(_)) | ty::Infer(ty::FreshFloatTy(_)) => - bug!("is_trivially_sized applied to unexpected type: {:?}", self), + bug!("`is_trivially_sized` applied to unexpected type: {:?}", self), } } } diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs index 76afba220ce..0c9fbfe6641 100644 --- a/src/librustc/ty/util.rs +++ b/src/librustc/ty/util.rs @@ -333,14 +333,14 @@ impl<'tcx> TyCtxt<'tcx> { ty } - /// Same as applying struct_tail on `source` and `target`, but only + /// Same as applying `struct_tail` on `source` and `target`, but only /// keeps going as long as the two types are instances of the same /// structure definitions. /// For `(Foo<Foo<T>>, Foo<dyn Trait>)`, the result will be `(Foo<T>, Trait)`, /// whereas struct_tail produces `T`, and `Trait`, respectively. /// /// Should only be called if the types have no inference variables and do - /// not need their lifetimes preserved (e.g. as part of codegen); otherwise + /// not need their lifetimes preserved (e.g., as part of codegen); otherwise, /// normalization attempt may cause compiler bugs. pub fn struct_lockstep_tails_erasing_lifetimes(self, source: Ty<'tcx>, @@ -353,7 +353,7 @@ impl<'tcx> TyCtxt<'tcx> { source, target, |ty| tcx.normalize_erasing_regions(param_env, ty)) } - /// Same as applying struct_tail on `source` and `target`, but only + /// Same as applying `struct_tail` on `source` and `target`, but only /// keeps going as long as the two types are instances of the same /// structure definitions. /// For `(Foo<Foo<T>>, Foo<dyn Trait>)`, the result will be `(Foo<T>, Trait)`, |