Address smaller changes

Author: natsukagami

library/src/scala/collection/Iterable.scala

@@ -467,15 +467,15 @@ transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] w
     *  @return a $coll consisting of all elements of this $coll except the last `n` ones, or else the
     *          empty $coll, if this $coll has less than `n` elements.
     *          If `n` is negative, don't drop any elements.
-  ^{this}  */
+    */
   def dropRight(n: Int): C^{this} = fromSpecific(new View.DropRight(this, n))
 
   def dropWhile(p: A => Boolean): C^{this, p} = fromSpecific(new View.DropWhile(this, p))
 
   /** Partitions elements in fixed size ${coll}s.
    *  @see [[scala.collection.Iterator]], method `grouped`
    *
-   *  @param si^{this}ze the number of elements per group
+   *  @param size the number of elements per group
    *  @return An iterator producing ${coll}s of size `size`, except the
    *          last will be less than size `size` if the elements don't divide evenly.
    */

library/src/scala/collection/mutable/LongMap.scala

@@ -470,7 +470,7 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff
 
   @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
   override def + [V1 >: V](elem1: (Long, V1), elem2: (Long, V1), elems: (Long, V1)*): LongMap[V1]^{} = {
-    // An empty capture annotation is needed in the result type to satisfy the overriding checker.
+    // TODO: An empty capture annotation is needed in the result type to satisfy the overriding checker.
     val m = this + elem1 + elem2
     if(elems.isEmpty) m else m.concat(elems)
   }

library/src/scala/collection/mutable/TreeMap.scala

@@ -168,7 +168,6 @@ sealed class TreeMap[K, V] private (tree: RB.Tree[K, V])(implicit val ordering:
     *              bound.
     */
   private[this] final class TreeMapProjection(from: Option[K], until: Option[K]) extends TreeMap[K, V](tree) {
-    this: TreeMapProjection^{} =>
 
     /**
       * Given a possible new lower bound, chooses and returns the most constraining one (the maximum).