Various cosmetic improvements

Author: Alexander Regueiro

src/librustc/hir/map/def_collector.rs

@@ -116,7 +116,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
         debug!("visit_item: {:?}", i);
 
         // Pick the def data. This need not be unique, but the more
-        // information we encapsulate into, the better
+        // information we encapsulate into, the better.
         let def_data = match i.node {
             ItemKind::Impl(..) => DefPathData::Impl,
             ItemKind::Trait(..) => DefPathData::Trait(i.ident.as_interned_str()),

src/librustc/hir/map/definitions.rs

@@ -1,4 +1,4 @@
-//! For each definition, we track the following data.  A definition
+//! For each definition, we track the following data. A definition
 //! here is defined somewhat circularly as "something with a def-id",
 //! but it generally corresponds to things like structs, enums, etc.
 //! There are also some rather random cases (like const initializer
@@ -114,7 +114,7 @@ impl Encodable for DefPathTable {
         self.index_to_key[DefIndexAddressSpace::Low.index()].encode(s)?;
         self.index_to_key[DefIndexAddressSpace::High.index()].encode(s)?;
 
-        // DefPath hashes
+        // `DefPath` hashes
         self.def_path_hashes[DefIndexAddressSpace::Low.index()].encode(s)?;
         self.def_path_hashes[DefIndexAddressSpace::High.index()].encode(s)?;
 

src/librustc/infer/nll_relate/mod.rs

@@ -373,7 +373,7 @@ where
     }
 
     fn trait_object_mode(&self) -> relate::TraitObjectMode {
-        // squashing should only be done in coherence, not NLL
+        // Squashing should only be done in coherence, not in NLL.
         assert_eq!(self.infcx.trait_object_mode(),
                    relate::TraitObjectMode::NoSquash);
         relate::TraitObjectMode::NoSquash

src/librustc/traits/specialize/mod.rs

@@ -305,7 +305,7 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(
 
     for impl_def_id in trait_impls {
         if impl_def_id.is_local() {
-            // This is where impl overlap checking happens:
+            // This is where impl overlap checking happens.
             let insert_result = sg.insert(tcx, impl_def_id);
             // Report error if there was one.
             let (overlap, used_to_be_allowed) = match insert_result {
@@ -381,7 +381,7 @@ pub(super) fn specialization_graph_provider<'a, 'tcx>(
     Lrc::new(sg)
 }
 
-/// Recovers the "impl X for Y" signature from `impl_def_id` and returns it as a
+/// Recovers the `impl X for Y` signature from `impl_def_id` and returns it as a
 /// string.
 fn to_pretty_impl_header(tcx: TyCtxt<'_, '_, '_>, impl_def_id: DefId) -> Option<String> {
     use std::fmt::Write;
@@ -396,8 +396,8 @@ fn to_pretty_impl_header(tcx: TyCtxt<'_, '_, '_>, impl_def_id: DefId) -> Option<
 
     let substs = Substs::identity_for_item(tcx, impl_def_id);
 
-    // FIXME: Currently only handles ?Sized.
-    //        Needs to support ?Move and ?DynSized when they are implemented.
+    // FIXME: currently only handles `?Sized`; needs to support `?Move` and `?DynSized` when
+    // they are implemented.
     let mut types_without_default_bounds = FxHashSet::default();
     let sized_trait = tcx.lang_items().sized_trait();
 

src/librustc/traits/specialize/specialization_graph.rs

@@ -30,11 +30,10 @@ use util::nodemap::{DefIdMap, FxHashMap};
 ///   has at most one parent.
 #[derive(RustcEncodable, RustcDecodable)]
 pub struct Graph {
-    // All impls have a parent; the "root" impls have as their parent the `def_id`
-    // of the trait.
+    // All impls have a parent; the "root" impls have as their parent the trait's def-ID.
     parent: DefIdMap<DefId>,
 
-    // The "root" impls are found by looking up the trait's def_id.
+    // The "root" impls are found by looking up the trait's def-ID.
     children: DefIdMap<Children>,
 }
 
@@ -63,12 +62,13 @@ struct Children {
 pub enum FutureCompatOverlapErrorKind {
     Issue43355,
     Issue33140,
+    Issue57057,
 }
 
 #[derive(Debug)]
 pub struct FutureCompatOverlapError {
     pub error: OverlapError,
-    pub kind: FutureCompatOverlapErrorKind
+    pub kind: FutureCompatOverlapErrorKind,
 }
 
 /// The result of attempting to insert an impl into a group of children.
@@ -204,8 +204,8 @@ impl<'a, 'gcx, 'tcx> Children {
                 replace_children.push(possible_sibling);
             } else {
                 if !tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling) {
-                    // do future-compat checks for overlap. Have issue #43355
-                    // errors overwrite issue #33140 errors when both are present.
+                    // Do future-compat checks for overlap.
+                    // Make issue #43355 errors overwrite issue #33140 errors when both are present.
 
                     traits::overlapping_impls(
                         tcx,
@@ -238,7 +238,7 @@ impl<'a, 'gcx, 'tcx> Children {
                     );
                 }
 
-                // no overlap (error bailed already via ?)
+                // No overlap (error bailed already via `?`).
             }
         }
 

src/librustc/ty/context.rs

@@ -1,4 +1,4 @@
-//! type context book-keeping
+//! Type context book-keeping.
 
 use dep_graph::DepGraph;
 use dep_graph::{DepNode, DepConstructor};

src/librustc/ty/mod.rs

@@ -2499,9 +2499,9 @@ impl<'a, 'gcx, 'tcx> FieldDef {
 /// `tcx.closure_env_ty()`.
 #[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
 pub enum ClosureKind {
-    // Warning: Ordering is significant here! The ordering is chosen
-    // because the trait Fn is a subtrait of FnMut and so in turn, and
-    // hence we order it so that Fn < FnMut < FnOnce.
+    // Warning: ordering is significant here! The ordering is chosen
+    // because the trait `Fn` is a subtrait of `FnMut` and so in turn, and
+    // hence we order it so that `Fn < FnMut < FnOnce`.
     Fn,
     FnMut,
     FnOnce,
@@ -2852,7 +2852,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             self.original_crate_name(id.krate).as_interned_str()
         } else {
             let def_key = self.def_key(id);
-            // The name of a StructCtor is that of its struct parent.
+            // The name of a `StructCtor` is that of its parent struct.
             if let hir_map::DefPathData::StructCtor = def_key.disambiguated_data.data {
                 self.item_name(DefId {
                     krate: id.krate,

src/librustc/ty/relate.rs

@@ -22,15 +22,16 @@ pub type RelateResult<'tcx, T> = Result<T, TypeError<'tcx>>;
 
 #[derive(Clone, Debug)]
 pub enum Cause {
-    ExistentialRegionBound, // relating an existential region bound
+    /// Relating to an existential region bound.
+    ExistentialRegionBound,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum TraitObjectMode {
     NoSquash,
-    /// A temporary mode to treat `Send + Sync = Sync + Send`, should be
-    /// used only in coherence.
-    SquashAutoTraitsIssue33140
+    /// A temporary mode to treat `Send + Sync == Sync + Send` (e.g.); should be
+    /// used only in coherence checking.
+    SquashAutoTraitsIssue33140,
 }
 
 pub trait TypeRelation<'a, 'gcx: 'a+'tcx, 'tcx: 'a> : Sized {
@@ -609,13 +610,13 @@ impl<'tcx> Relate<'tcx> for &'tcx ty::List<ty::ExistentialPredicate<'tcx>> {
             TraitObjectMode::SquashAutoTraitsIssue33140 => {
                 // Treat auto-trait "principal" components as equal
                 // to the non-principal components, to make
-                // `dyn Send+Sync = dyn Sync+Send`.
+                // `dyn Send + Sync = dyn Sync + Send`.
                 let normalize = |d: &[ty::ExistentialPredicate<'tcx>]| {
                     let mut result: Vec<_> = d.iter().map(|pi| match pi {
                         Trait(ref a) if tcx.trait_is_auto(a.def_id) => {
                             AutoTrait(a.def_id)
                         },
-                        other => *other
+                        other => *other,
                     }).collect();
 
                     result.sort_by(|a, b| a.stable_cmp(tcx, b));

src/librustc/ty/wf.rs

@@ -38,7 +38,7 @@ pub fn obligations<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
 }
 
 /// Returns the obligations that make this trait reference
-/// well-formed.  For example, if there is a trait `Set` defined like
+/// well-formed. For example, if there is a trait `Set` defined like
 /// `trait Set<K:Eq>`, then the trait reference `Foo: Set<Bar>` is WF
 /// if `Bar: Eq`.
 pub fn trait_obligations<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
@@ -190,7 +190,7 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
     /// into `self.out`.
     fn compute_projection(&mut self, data: ty::ProjectionTy<'tcx>) {
         // A projection is well-formed if (a) the trait ref itself is
-        // WF and (b) the trait-ref holds.  (It may also be
+        // WF and (b) the trait-ref holds. (It may also be
         // normalizable and be WF that way.)
         let trait_ref = data.trait_ref(self.infcx.tcx);
         self.compute_trait_ref(&trait_ref, Elaborate::None);
@@ -251,7 +251,7 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 ty::Bound(..) |
                 ty::Placeholder(..) |
                 ty::Foreign(..) => {
-                    // WfScalar, WfParameter, etc
+                    // `WfScalar`, `WfParameter`, etc.
                 }
 
                 ty::Slice(subty) => {
@@ -273,18 +273,19 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 }
 
                 ty::RawPtr(_) => {
-                    // simple cases that are WF if their type args are WF
+                    // Simple cases that are WF if their type args are WF.
                 }
 
                 ty::Projection(data) => {
-                    subtys.skip_current_subtree(); // subtree handled by compute_projection
+                    // Subtree is handled by `compute_projection`.
+                    subtys.skip_current_subtree();
                     self.compute_projection(data);
                 }
 
                 ty::UnnormalizedProjection(..) => bug!("only used with chalk-engine"),
 
                 ty::Adt(def, substs) => {
-                    // WfNominalType
+                    // `WfNominalType`
                     let obligations = self.nominal_obligations(def.did, substs);
                     self.out.extend(obligations);
                 }
@@ -295,7 +296,7 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 }
 
                 ty::Ref(r, rty, _) => {
-                    // WfReference
+                    // `WfReference`
                     if !r.has_escaping_bound_vars() && !rty.has_escaping_bound_vars() {
                         let cause = self.cause(traits::ReferenceOutlivesReferent(ty));
                         self.out.push(
@@ -309,7 +310,7 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 }
 
                 ty::Generator(..) => {
-                    // Walk ALL the types in the generator: this will
+                    // Walk _all_ the types in the generator: this will
                     // include the upvar types as well as the yield
                     // type. Note that this is mildly distinct from
                     // the closure case, where we have to be careful
@@ -355,32 +356,32 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 }
 
                 ty::FnPtr(_) => {
-                    // let the loop iterate into the argument/return
-                    // types appearing in the fn signature
+                    // Let the loop iterate into the argument/return
+                    // types appearing in the fn signature.
                 }
 
                 ty::Opaque(did, substs) => {
-                    // all of the requirements on type parameters
+                    // All of the requirements on type parameters
                     // should've been checked by the instantiation
                     // of whatever returned this exact `impl Trait`.
 
-                    // for named existential types we still need to check them
+                    // For named existential types, we still need to check them.
                     if super::is_impl_trait_defn(self.infcx.tcx, did).is_none() {
                         let obligations = self.nominal_obligations(did, substs);
                         self.out.extend(obligations);
                     }
                 }
 
                 ty::Dynamic(data, r) => {
-                    // WfObject
+                    // `WfObject`
                     //
                     // Here, we defer WF checking due to higher-ranked
                     // regions. This is perhaps not ideal.
                     self.from_object_ty(ty, data, r);
 
-                    // FIXME(#27579) RFC also considers adding trait
-                    // obligations that don't refer to Self and
-                    // checking those
+                    // FIXME(#27579): RFC also considers adding trait
+                    // obligations that don't refer to `Self` and
+                    // checking those.
 
                     let cause = self.cause(traits::MiscObligation);
                     let component_traits =
@@ -398,9 +399,9 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 // know what type they are. We do two things:
                 //
                 // 1. Check if they have been resolved, and if so proceed with
-                //    THAT type.
+                //    _that_ type.
                 // 2. If not, check whether this is the type that we
-                //    started with (ty0). In that case, we've made no
+                //    started with (`ty0`). In that case, we've made no
                 //    progress at all, so return false. Otherwise,
                 //    we've at least simplified things (i.e., we went
                 //    from `Vec<$0>: WF` to `$0: WF`, so we can
@@ -409,27 +410,30 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> {
                 //    is satisfied to ensure termination.)
                 ty::Infer(_) => {
                     let ty = self.infcx.shallow_resolve(ty);
-                    if let ty::Infer(_) = ty.sty { // not yet resolved...
-                        if ty == ty0 { // ...this is the type we started from! no progress.
+                    if let ty::Infer(_) = ty.sty {
+                        // Not yet resolved...
+                        if ty == ty0 {
+                            // ... this is the type we started from, so no progress!
                             return false;
                         }
 
                         let cause = self.cause(traits::MiscObligation);
-                        self.out.push( // ...not the type we started from, so we made progress.
+                        self.out.push(
+                            // ... this is not the type we started from, so we made progress.
                             traits::Obligation::new(cause,
                                                     self.param_env,
                                                     ty::Predicate::WellFormed(ty)));
                     } else {
                         // Yes, resolved, proceed with the
                         // result. Should never return false because
-                        // `ty` is not a Infer.
+                        // `ty` is not a `Infer`.
                         assert!(self.compute(ty));
                     }
                 }
             }
         }
 
-        // if we made it through that loop above, we made progress!
+        // If we made it through that loop above, we made progress!
         return true;
     }
 

src/librustc_lint/lib.rs

@@ -308,8 +308,8 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
             id: LintId::of(UNSTABLE_NAME_COLLISIONS),
             reference: "issue #48919 <https://github.com/rust-lang/rust/issues/48919>",
             edition: None,
-            // Note: this item represents future incompatibility of all unstable functions in the
-            //       standard library, and thus should never be removed or changed to an error.
+            // N.B., this item represents future incompatibility of all unstable functions in the
+            // standard library, and thus should never be removed or changed to an error.
         },
         FutureIncompatibleInfo {
             id: LintId::of(ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE),