Fix remaining cc errors

Author: noti0na1

library/src/scala/collection/convert/AsScalaConverters.scala

@@ -43,7 +43,7 @@ trait AsScalaConverters {
    */
   def asScala[A](i: ju.Iterator[A] | Null): Iterator[A] | Null = i match {
     case null                            => null
-    case wrapper: IteratorWrapper[A @uc] => wrapper.underlying
+    case wrapper: IteratorWrapper[A @uc] => wrapper.underlying.unsafeAssumePure // TODO: Remove when pattern matching recognizes this is safe
     case _                               => new JIteratorWrapper(i.nn)
   }
 
@@ -61,7 +61,7 @@ trait AsScalaConverters {
    */
   def asScala[A](e: ju.Enumeration[A] | Null): Iterator[A] | Null = e match {
     case null                            => null
-    case wrapper: IteratorWrapper[A @uc] => wrapper.underlying
+    case wrapper: IteratorWrapper[A @uc] => wrapper.underlying.unsafeAssumePure // TODO: Remove when pattern matching recognizes this is safe
     case _                               => new JEnumerationWrapper(e.nn)
   }
 
@@ -79,7 +79,7 @@ trait AsScalaConverters {
    */
   def asScala[A](i: jl.Iterable[A] | Null): Iterable[A] | Null = i match {
     case null                            => null
-    case wrapper: IterableWrapper[A @uc] => wrapper.underlying
+    case wrapper: IterableWrapper[A @uc] => wrapper.underlying.unsafeAssumePure // TODO: Remove when pattern matching recognizes this is safe
     case _                               => new JIterableWrapper(i.nn)
   }
 
@@ -94,7 +94,7 @@ trait AsScalaConverters {
    */
   def asScala[A](c: ju.Collection[A] | Null): Iterable[A] | Null = c match {
     case null                            => null
-    case wrapper: IterableWrapper[A @uc] => wrapper.underlying
+    case wrapper: IterableWrapper[A @uc] => wrapper.underlying.unsafeAssumePure // TODO: Remove when pattern matching recognizes this is safe
     case _                               => new JCollectionWrapper(c.nn)
   }
 

library/src/scala/collection/immutable/HashMap.scala

@@ -2202,7 +2202,7 @@ object HashMap extends MapFactory[HashMap] {
   def empty[K, V]: HashMap[K, V] =
     EmptyMap.asInstanceOf[HashMap[K, V]]
 
-  def from[K, V](source: collection.IterableOnce[(K, V)]): HashMap[K, V] =
+  def from[K, V](source: collection.IterableOnce[(K, V)]^): HashMap[K, V] =
     source match {
       case hs: HashMap[K, V] => hs
       case _ => (newBuilder[K, V] ++= source).result()

library/src/scala/collection/mutable/HashSet.scala

@@ -243,10 +243,10 @@ final class HashSet[A](initialCapacity: Int, loadFactor: Double)
   override def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S with EfficientSplit = {
     import convert.impl._
     val s = shape.shape match {
-      case StepperShape.IntShape    => new IntTableStepper[Node[A]]   (size, table, _.nn.next.nn, _.key.asInstanceOf[Int],    0, table.length)
-      case StepperShape.LongShape   => new LongTableStepper[Node[A]]  (size, table, _.nn.next.nn, _.key.asInstanceOf[Long],   0, table.length)
-      case StepperShape.DoubleShape => new DoubleTableStepper[Node[A]](size, table, _.nn.next.nn, _.key.asInstanceOf[Double], 0, table.length)
-      case _         => shape.parUnbox(new AnyTableStepper[A, Node[A]](size, table, _.nn.next.nn, _.key,                      0, table.length))
+      case StepperShape.IntShape    => new IntTableStepper[Node[A]]   (size, table, _.next.nn, _.key.asInstanceOf[Int],    0, table.length)
+      case StepperShape.LongShape   => new LongTableStepper[Node[A]]  (size, table, _.next.nn, _.key.asInstanceOf[Long],   0, table.length)
+      case StepperShape.DoubleShape => new DoubleTableStepper[Node[A]](size, table, _.next.nn, _.key.asInstanceOf[Double], 0, table.length)
+      case _         => shape.parUnbox(new AnyTableStepper[A, Node[A]](size, table, _.next.nn, _.key,                      0, table.length))
     }
     s.asInstanceOf[S with EfficientSplit]
   }

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

@@ -469,18 +469,18 @@ 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] = {
+  override def + [V1 >: V](elem1: (Long, V1), elem2: (Long, V1), elems: (Long, V1)*): LongMap[V1]^{} = {
     val m = this + elem1 + elem2
     if(elems.isEmpty) m else m.concat(elems)
   }
 
-  override def concat[V1 >: V](xs: scala.collection.IterableOnce[(Long, V1)]): LongMap[V1] = {
+  override def concat[V1 >: V](xs: scala.collection.IterableOnce[(Long, V1)]^): LongMap[V1] = {
     val lm = clone().asInstanceOf[LongMap[V1]]
     xs.iterator.foreach(kv => lm += kv)
     lm
   }
 
-  override def ++ [V1 >: V](xs: scala.collection.IterableOnce[(Long, V1)]): LongMap[V1] = concat(xs)
+  override def ++ [V1 >: V](xs: scala.collection.IterableOnce[(Long, V1)]^): LongMap[V1] = concat(xs)
 
   @deprecated("Use m.clone().addOne(k,v) instead of m.updated(k, v)", "2.13.0")
   override def updated[V1 >: V](key: Long, value: V1): LongMap[V1] =