remove imports to deprecated elements

Author: hamzaremmal

library/src/scala/collection/convert/ImplicitConversions.scala

@@ -20,12 +20,13 @@ import language.experimental.captureChecking
 import java.util.{concurrent => juc}
 import java.{lang => jl, util => ju}
 
-import scala.collection.JavaConverters._
 import scala.language.implicitConversions
 
 /** Defines implicit converter methods from Java to Scala collections. */
 @deprecated("Use `scala.jdk.CollectionConverters` instead", "2.13.0")
 trait ToScalaImplicits {
+  import scala.collection.JavaConverters.*
+
   /** Implicitly converts a Java `Iterator` to a Scala `Iterator`.
    *  @see [[JavaConverters.asScalaIterator]]
    */
@@ -80,6 +81,7 @@ trait ToScalaImplicits {
 /** Defines implicit conversions from Scala to Java collections. */
 @deprecated("Use `scala.jdk.CollectionConverters` instead", "2.13.0")
 trait ToJavaImplicits {
+  import scala.collection.JavaConverters.*
   /** Implicitly converts a Scala `Iterator` to a Java `Iterator`.
    *  @see [[JavaConverters.asJavaIterator]]
    */

library/src/scala/collection/immutable/Stream.scala

@@ -25,8 +25,6 @@ import scala.collection.mutable.{ArrayBuffer, StringBuilder}
 import scala.language.implicitConversions
 import scala.runtime.ScalaRunTime.nullForGC
 
-import Stream.cons
-
 @deprecated("Use LazyListIterable (which is fully lazy) instead of Stream (which has a lazy tail only)", "2.13.0")
 @SerialVersionUID(3L)
 sealed abstract class Stream[+A] extends AbstractSeq[A]
@@ -123,11 +121,11 @@ sealed abstract class Stream[+A] extends AbstractSeq[A]
     * @return The stream containing elements of this stream and the iterable object.
     */
   def lazyAppendedAll[B >: A](suffix: => collection.IterableOnce[B]): Stream[B] =
-    if (isEmpty) iterableFactory.from(suffix) else cons[B](head, tail.lazyAppendedAll(suffix))
+    if (isEmpty) iterableFactory.from(suffix) else Stream.cons[B](head, tail.lazyAppendedAll(suffix))
 
   override def scanLeft[B](z: B)(op: (B, A) => B): Stream[B] =
     if (isEmpty) z +: iterableFactory.empty
-    else cons(z, tail.scanLeft(op(z, head))(op))
+    else Stream.cons(z, tail.scanLeft(op(z, head))(op))
 
   /** Stream specialization of reduceLeft which allows GC to collect
     *  along the way.
@@ -169,11 +167,11 @@ sealed abstract class Stream[+A] extends AbstractSeq[A]
   override final def withFilter(p: A => Boolean): collection.WithFilter[A, Stream] =
     Stream.withFilter(coll, p)
 
-  override final def prepended[B >: A](elem: B): Stream[B] = cons(elem, coll)
+  override final def prepended[B >: A](elem: B): Stream[B] = Stream.cons(elem, coll)
 
   override final def map[B](f: A => B): Stream[B] =
     if (isEmpty) iterableFactory.empty
-    else cons(f(head), tail.map(f))
+    else Stream.cons(f(head), tail.map(f))
 
   @tailrec override final def collect[B](pf: PartialFunction[A, B]): Stream[B] =
     if(isEmpty) Stream.empty
@@ -218,7 +216,7 @@ sealed abstract class Stream[+A] extends AbstractSeq[A]
         case that: collection.Iterable[B] => that
         case _ => LazyList.from(that)
       }
-      cons[(A, B)]((this.head, thatIterable.head), this.tail.zip(thatIterable.tail))
+      Stream.cons[(A, B)]((this.head, thatIterable.head), this.tail.zip(thatIterable.tail))
     }
 
   override final def zipWithIndex: Stream[(A, Int)] = this.zip(LazyList.from(0))

library/src/scala/runtime/ScalaNumberProxy.scala

@@ -17,14 +17,13 @@ import scala.language.`2.13`
 import scala.collection.immutable
 import scala.math.ScalaNumericAnyConversions
 import immutable.NumericRange
-import Proxy.Typed
 import scala.annotation.nowarn
 
 /** Base classes for the Rich* wrappers of the primitive types.
  *  As with all classes in scala.runtime.*, this is not a supported API.
  */
 @nowarn("cat=deprecation")
-trait ScalaNumberProxy[T] extends Any with ScalaNumericAnyConversions with Typed[T] with OrderedProxy[T] {
+trait ScalaNumberProxy[T] extends Any with ScalaNumericAnyConversions with Proxy.Typed[T] with OrderedProxy[T] {
   protected implicit def num: Numeric[T]
 
   def doubleValue = num.toDouble(self)
@@ -70,14 +69,14 @@ trait FractionalProxy[T] extends Any with ScalaNumberProxy[T] {
 }
 
 @nowarn("cat=deprecation")
-trait OrderedProxy[T] extends Any with Ordered[T] with Typed[T] {
+trait OrderedProxy[T] extends Any with Ordered[T] with Proxy.Typed[T] {
   protected def ord: Ordering[T]
 
   def compare(y: T) = ord.compare(self, y)
 }
 
 @nowarn("cat=deprecation")
-trait RangedProxy[T] extends Any with Typed[T] {
+trait RangedProxy[T] extends Any with Proxy.Typed[T] {
   type ResultWithoutStep
 
   def until(end: T): ResultWithoutStep