Fix compiling with the 2.13 collections

- Always rely on -Ynew-collections to change our behavior, attempting to
automatically detect which version we're on leads to cycles.
- In the new collections, the scala.Serializable class has been replaced
by a type alias of java.io.Serializable
- The `<:<` class was moved from the Predef object to the scala package.

Author: smarter

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -347,16 +347,19 @@ class Definitions {
 
   lazy val ScalaPredefModuleRef: TermRef = ctx.requiredModuleRef("scala.Predef")
   def ScalaPredefModule(implicit ctx: Context): Symbol = ScalaPredefModuleRef.symbol
-
-    lazy val Predef_ConformsR: TypeRef = ScalaPredefModule.requiredClass("<:<").typeRef
-    def Predef_Conforms(implicit ctx: Context): Symbol = Predef_ConformsR.symbol
     lazy val Predef_conformsR: TermRef = ScalaPredefModule.requiredMethodRef(nme.conforms_)
     def Predef_conforms(implicit ctx: Context): Symbol = Predef_conformsR.symbol
     lazy val Predef_classOfR: TermRef = ScalaPredefModule.requiredMethodRef(nme.classOf)
     def Predef_classOf(implicit ctx: Context): Symbol = Predef_classOfR.symbol
     lazy val Predef_undefinedR: TermRef = ScalaPredefModule.requiredMethodRef(nme.???)
     def Predef_undefined(implicit ctx: Context): Symbol = Predef_undefinedR.symbol
 
+  def SubTypeClass(implicit ctx: Context): Symbol =
+    if (isNewCollections)
+      ctx.requiredClass("scala.<:<")
+    else
+      ScalaPredefModule.requiredClass("<:<")
+
   lazy val ScalaRuntimeModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.ScalaRunTime")
   def ScalaRuntimeModule(implicit ctx: Context): Symbol = ScalaRuntimeModuleRef.symbol
   def ScalaRuntimeClass(implicit ctx: Context): ClassSymbol = ScalaRuntimeModule.moduleClass.asClass
@@ -397,8 +400,7 @@ class Definitions {
     def newArrayMethod(implicit ctx: Context): TermSymbol = DottyArraysModule.requiredMethod("newArray")
 
   // TODO: Remove once we drop support for 2.12 standard library
-  lazy val isNewCollections: Boolean = ctx.settings.YnewCollections.value ||
-    ctx.base.staticRef("scala.collection.IterableOnce".toTypeName).exists
+  lazy val isNewCollections: Boolean = ctx.settings.YnewCollections.value
 
   def getWrapVarargsArrayModule: Symbol = if (isNewCollections) ScalaRuntimeModule else ScalaPredefModule
 
@@ -585,7 +587,11 @@ class Definitions {
 
   lazy val ThrowableType: TypeRef          = ctx.requiredClassRef("java.lang.Throwable")
   def ThrowableClass(implicit ctx: Context): ClassSymbol = ThrowableType.symbol.asClass
-  lazy val SerializableType: TypeRef       = ctx.requiredClassRef("scala.Serializable")
+  lazy val SerializableType: TypeRef       =
+    if (isNewCollections)
+      JavaSerializableClass.typeRef
+    else
+      ctx.requiredClassRef("scala.Serializable")
   def SerializableClass(implicit ctx: Context): ClassSymbol = SerializableType.symbol.asClass
   lazy val StringBuilderType: TypeRef      = ctx.requiredClassRef("scala.collection.mutable.StringBuilder")
   def StringBuilderClass(implicit ctx: Context): ClassSymbol = StringBuilderType.symbol.asClass

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -140,7 +140,9 @@ object Implicits {
                 ctx.scala2Mode && tpw.derivesFrom(defn.FunctionClass(1)) && ref.symbol != defn.Predef_conforms
               val isImplicitConverter = tpw.derivesFrom(defn.Predef_ImplicitConverter)
               val isConforms = // An implementation of <:< counts as a view, except that $conforms is always omitted
-                  tpw.derivesFrom(defn.Predef_Conforms) && ref.symbol != defn.Predef_conforms
+                  tpw.derivesFrom(defn.SubTypeClass) &&
+                    (defn.isNewCollections || // In 2.13, the type of `$conforms` changed from `A <:< A` to `A => A`
+                     ref.symbol != defn.Predef_conforms)
               val hasExtensions = resType match {
                 case SelectionProto(name, _, _, _) =>
                   tpw.memberBasedOnFlags(name, required = ExtensionMethod).exists