Remove meaningless comment decoration from code

src/libcore/convert.rs

@@ -489,9 +489,7 @@ pub trait TryFrom<T>: Sized {
     fn try_from(value: T) -> Result<Self, Self::Error>;
 }
 
-////////////////////////////////////////////////////////////////////////////////
 // GENERIC IMPLS
-////////////////////////////////////////////////////////////////////////////////
 
 // As lifts over &
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -574,9 +572,7 @@ impl<T, U> TryFrom<U> for T where U: Into<T> {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
 // CONCRETE IMPLS
-////////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> AsRef<[T]> for [T] {
@@ -600,9 +596,7 @@ impl AsRef<str> for str {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
 // THE NO-ERROR ERROR TYPE
-////////////////////////////////////////////////////////////////////////////////
 
 /// The error type for errors that can never happen.
 ///

src/libcore/option.rs

@@ -156,14 +156,10 @@ pub enum Option<T> {
     Some(#[stable(feature = "rust1", since = "1.0.0")] T),
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Type implementation
-/////////////////////////////////////////////////////////////////////////////
 
 impl<T> Option<T> {
-    /////////////////////////////////////////////////////////////////////////
     // Querying the contained values
-    /////////////////////////////////////////////////////////////////////////
 
     /// Returns `true` if the option is a [`Some`] value.
     ///
@@ -235,9 +231,7 @@ impl<T> Option<T> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Adapter for working with references
-    /////////////////////////////////////////////////////////////////////////
 
     /// Converts from `&Option<T>` to `Option<&T>`.
     ///
@@ -312,9 +306,7 @@ impl<T> Option<T> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Getting to contained values
-    /////////////////////////////////////////////////////////////////////////
 
     /// Unwraps an option, yielding the content of a [`Some`].
     ///
@@ -420,9 +412,7 @@ impl<T> Option<T> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Transforming contained values
-    /////////////////////////////////////////////////////////////////////////
 
     /// Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.
     ///
@@ -552,9 +542,7 @@ impl<T> Option<T> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Iterator constructors
-    /////////////////////////////////////////////////////////////////////////
 
     /// Returns an iterator over the possibly contained value.
     ///
@@ -594,9 +582,7 @@ impl<T> Option<T> {
         IterMut { inner: Item { opt: self.as_mut() } }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Boolean operations on the values, eager and lazy
-    /////////////////////////////////////////////////////////////////////////
 
     /// Returns [`None`] if the option is [`None`], otherwise returns `optb`.
     ///
@@ -786,9 +772,7 @@ impl<T> Option<T> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Entry-like operations to insert if None and return a reference
-    /////////////////////////////////////////////////////////////////////////
 
     /// Inserts `v` into the option if it is [`None`], then
     /// returns a mutable reference to the contained value.
@@ -848,9 +832,7 @@ impl<T> Option<T> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Misc
-    /////////////////////////////////////////////////////////////////////////
 
     /// Takes the value out of the option, leaving a [`None`] in its place.
     ///
@@ -1173,9 +1155,7 @@ fn expect_none_failed(msg: &str, value: &dyn fmt::Debug) -> ! {
     panic!("{}: {:?}", msg, value)
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Trait implementations
-/////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone> Clone for Option<T> {
@@ -1268,9 +1248,7 @@ impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T> {
     }
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // The Option Iterators
-/////////////////////////////////////////////////////////////////////////////
 
 #[derive(Clone, Debug)]
 struct Item<A> {
@@ -1426,9 +1404,7 @@ impl<A> FusedIterator for IntoIter<A> {}
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A> TrustedLen for IntoIter<A> {}
 
-/////////////////////////////////////////////////////////////////////////////
 // FromIterator
-/////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {

src/libcore/result.rs

@@ -253,14 +253,10 @@ pub enum Result<T, E> {
     Err(#[stable(feature = "rust1", since = "1.0.0")] E),
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Type implementation
-/////////////////////////////////////////////////////////////////////////////
 
 impl<T, E> Result<T, E> {
-    /////////////////////////////////////////////////////////////////////////
     // Querying the contained values
-    /////////////////////////////////////////////////////////////////////////
 
     /// Returns `true` if the result is [`Ok`].
     ///
@@ -361,9 +357,7 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Adapter for each variant
-    /////////////////////////////////////////////////////////////////////////
 
     /// Converts from `Result<T, E>` to [`Option<T>`].
     ///
@@ -419,9 +413,7 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Adapter for working with references
-    /////////////////////////////////////////////////////////////////////////
 
     /// Converts from `&Result<T, E>` to `Result<&T, &E>`.
     ///
@@ -479,9 +471,7 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Transforming contained values
-    /////////////////////////////////////////////////////////////////////////
 
     /// Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a
     /// contained [`Ok`] value, leaving an [`Err`] value untouched.
@@ -575,9 +565,7 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /////////////////////////////////////////////////////////////////////////
     // Iterator constructors
-    /////////////////////////////////////////////////////////////////////////
 
     /// Returns an iterator over the possibly contained value.
     ///
@@ -625,9 +613,7 @@ impl<T, E> Result<T, E> {
         IterMut { inner: self.as_mut().ok() }
     }
 
-    ////////////////////////////////////////////////////////////////////////
     // Boolean operations on the values, eager and lazy
-    /////////////////////////////////////////////////////////////////////////
 
     /// Returns `res` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.
     ///
@@ -1084,9 +1070,7 @@ fn unwrap_failed(msg: &str, error: &dyn fmt::Debug) -> ! {
     panic!("{}: {:?}", msg, error)
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Trait implementations
-/////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone, E: Clone> Clone for Result<T, E> {
@@ -1157,9 +1141,7 @@ impl<'a, T, E> IntoIterator for &'a mut Result<T, E> {
     }
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // The Result Iterators
-/////////////////////////////////////////////////////////////////////////////
 
 /// An iterator over a reference to the [`Ok`] variant of a [`Result`].
 ///
@@ -1290,9 +1272,7 @@ impl<T> FusedIterator for IntoIter<T> {}
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A> TrustedLen for IntoIter<A> {}
 
-/////////////////////////////////////////////////////////////////////////////
 // FromIterator
-/////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {

src/libcore/slice/mod.rs

@@ -2963,9 +2963,7 @@ impl<T> SliceIndex<[T]> for ops::RangeToInclusive<usize> {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
 // Common traits
-////////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Default for &[T] {
@@ -2979,9 +2977,7 @@ impl<T> Default for &mut [T] {
     fn default() -> Self { &mut [] }
 }
 
-//
 // Iterators
-//
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> IntoIterator for &'a [T] {

src/libcore/str/pattern.rs

@@ -234,9 +234,7 @@ pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
 pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> {}
 
 
-/////////////////////////////////////////////////////////////////////////////
 // Impl for char
-/////////////////////////////////////////////////////////////////////////////
 
 /// Associated type for `<char as Pattern<'a>>::Searcher`.
 #[derive(Clone, Debug)]
@@ -466,9 +464,7 @@ impl<'a> Pattern<'a> for char {
     }
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Impl for a MultiCharEq wrapper
-/////////////////////////////////////////////////////////////////////////////
 
 #[doc(hidden)]
 trait MultiCharEq {
@@ -556,8 +552,6 @@ unsafe impl<'a, C: MultiCharEq> ReverseSearcher<'a> for MultiCharEqSearcher<'a,
 
 impl<'a, C: MultiCharEq> DoubleEndedSearcher<'a> for MultiCharEqSearcher<'a, C> {}
 
-/////////////////////////////////////////////////////////////////////////////
-
 macro_rules! pattern_methods {
     ($t:ty, $pmap:expr, $smap:expr) => {
         type Searcher = $t;
@@ -621,9 +615,7 @@ macro_rules! searcher_methods {
     }
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Impl for &[char]
-/////////////////////////////////////////////////////////////////////////////
 
 // Todo: Change / Remove due to ambiguity in meaning.
 
@@ -646,9 +638,7 @@ impl<'a, 'b> Pattern<'a> for &'b [char] {
     pattern_methods!(CharSliceSearcher<'a, 'b>, MultiCharEqPattern, CharSliceSearcher);
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Impl for F: FnMut(char) -> bool
-/////////////////////////////////////////////////////////////////////////////
 
 /// Associated type for `<F as Pattern<'a>>::Searcher`.
 #[derive(Clone)]
@@ -685,18 +675,14 @@ impl<'a, F> Pattern<'a> for F where F: FnMut(char) -> bool {
     pattern_methods!(CharPredicateSearcher<'a, F>, MultiCharEqPattern, CharPredicateSearcher);
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Impl for &&str
-/////////////////////////////////////////////////////////////////////////////
 
 /// Delegates to the `&str` impl.
 impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {
     pattern_methods!(StrSearcher<'a, 'b>, |&s| s, |s| s);
 }
 
-/////////////////////////////////////////////////////////////////////////////
 // Impl for &str
-/////////////////////////////////////////////////////////////////////////////
 
 /// Non-allocating substring search.
 ///
@@ -727,9 +713,7 @@ impl<'a, 'b> Pattern<'a> for &'b str {
 }
 
 
-/////////////////////////////////////////////////////////////////////////////
 // Two Way substring searcher
-/////////////////////////////////////////////////////////////////////////////
 
 #[derive(Clone, Debug)]
 /// Associated type for `<&str as Pattern<'a>>::Searcher`.

src/librustc/hir/intravisit.rs

@@ -140,7 +140,6 @@ impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> {
 /// to monitor future changes to `Visitor` in case a new method with a
 /// new default implementation gets introduced.)
 pub trait Visitor<'v> : Sized {
-    ///////////////////////////////////////////////////////////////////////////
     // Nested items.
 
     /// The default versions of the `visit_nested_XXX` routines invoke
@@ -234,8 +233,6 @@ pub trait Visitor<'v> : Sized {
         DeepVisitor::new(self)
     }
 
-    ///////////////////////////////////////////////////////////////////////////
-
     fn visit_id(&mut self, _hir_id: HirId) {
         // Nothing to do.
     }

src/librustc/infer/combine.rs

@@ -1,4 +1,3 @@
-///////////////////////////////////////////////////////////////////////////
 // # Type combining
 //
 // There are four type combiners: equate, sub, lub, and glb.  Each

src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs

@@ -18,13 +18,11 @@ impl NiceRegionError<'me, 'tcx> {
     /// an anonymous region, emit a descriptive diagnostic error.
     pub(super) fn try_report_placeholder_conflict(&self) -> Option<DiagnosticBuilder<'me>> {
         match &self.error {
-            ///////////////////////////////////////////////////////////////////////////
             // NB. The ordering of cases in this match is very
             // sensitive, because we are often matching against
             // specific cases and then using an `_` to match all
             // others.
 
-            ///////////////////////////////////////////////////////////////////////////
             // Check for errors from comparing trait failures -- first
             // with two placeholders, then with one.
             Some(RegionResolutionError::SubSupConflict(

src/librustc/infer/resolve.rs

@@ -4,7 +4,6 @@ use crate::mir::interpret::ConstValue;
 use crate::ty::{self, Ty, Const, TyCtxt, TypeFoldable, InferConst, TypeFlags};
 use crate::ty::fold::{TypeFolder, TypeVisitor};
 
-///////////////////////////////////////////////////////////////////////////
 // OPPORTUNISTIC VAR RESOLVER
 
 /// The opportunistic resolver can be used at any time. It simply replaces
@@ -94,7 +93,6 @@ impl<'a, 'tcx> TypeFolder<'tcx> for OpportunisticTypeAndRegionResolver<'a, 'tcx>
     }
 }
 
-///////////////////////////////////////////////////////////////////////////
 // UNRESOLVED TYPE FINDER
 
 /// The unresolved type **finder** walks a type searching for
@@ -151,7 +149,6 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for UnresolvedTypeFinder<'a, 'tcx> {
 }
 
 
-///////////////////////////////////////////////////////////////////////////
 // FULL TYPE RESOLUTION
 
 /// Full type resolution replaces all type and region variables with