Treat Scala.js pseudo-unions in Scala 2 symbols as real unions

When unpickling a Scala 2 symbol, we now treat `scala.scalajs.js.|[A,
B]` as if it were a real `A | B`, this requires a special-case in erasure
to emit the correct signatures in SJSIR.

Remaining issues after this commit fixed in later commits of this PR:
- The companion object of `js.|` defines implicit conversions like
  `undefOr2ops`, those are no longer automatically in scope for values
  with a union type (which breaks many JUnitTests).
- When compiling Scala.js code from source, `A | B` is interpreted
  as `js.|[A, B]` if `js.|` is in scope (e.g. via an import).

Additionally, a few tests had to be disabled until we can depend on
their fixed upstream version (scala-js/scala-js#4451).

Author: smarter

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

@@ -6,6 +6,7 @@ import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Phases._
 import Flags.JavaDefined
 import Uniques.unique
 import TypeOps.makePackageObjPrefixExplicit
+import backend.sjs.JSDefinitions
 import transform.ExplicitOuter._
 import transform.ValueClasses._
 import transform.TypeUtils._
@@ -523,7 +524,19 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       else
         erasedGlb(this(tp1), this(tp2), isJava = sourceLanguage.isJava)
     case OrType(tp1, tp2) =>
-      TypeComparer.orType(this(tp1), this(tp2), isErased = true)
+      if isSymbol && sourceLanguage.isScala2 && ctx.settings.scalajs.value then
+        // In Scala2Unpickler we unpickle Scala.js pseudo-unions as if they were
+        // real unions, but we must still erase them as Scala 2 would to emit
+        // the correct signatures in SJSIR.
+        // We only do this when `isSymbol` is true since in other situations we
+        // cannot distinguish a Scala.js pseudo-union from a Scala 3 union that
+        // has been substituted into a Scala 2 type (e.g., via `asSeenFrom`),
+        // erasing these unions as if they were pseudo-unions could have an
+        // impact on overriding relationships so it's best to leave them
+        // alone (and this doesn't impact the SJSIR we generate).
+        JSDefinitions.jsdefn.PseudoUnionType
+      else
+        TypeComparer.orType(this(tp1), this(tp2), isErased = true)
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)(tpToErase)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -13,6 +13,7 @@ import NameKinds.{Scala2MethodNameKinds, SuperAccessorName, ExpandedName}
 import util.Spans._
 import dotty.tools.dotc.ast.{tpd, untpd}, ast.tpd._
 import ast.untpd.Modifiers
+import backend.sjs.JSDefinitions
 import printing.Texts._
 import printing.Printer
 import io.AbstractFile
@@ -675,6 +676,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
 
     def removeSingleton(tp: Type): Type =
       if (tp isRef defn.SingletonClass) defn.AnyType else tp
+    def mapArg(arg: Type) = arg match {
+      case arg: TypeRef if isBound(arg) => arg.symbol.info
+      case _ => arg
+    }
     def elim(tp: Type): Type = tp match {
       case tp @ RefinedType(parent, name, rinfo) =>
         val parent1 = elim(tp.parent)
@@ -690,12 +695,11 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         }
       case tp @ AppliedType(tycon, args) =>
         val tycon1 = tycon.safeDealias
-        def mapArg(arg: Type) = arg match {
-          case arg: TypeRef if isBound(arg) => arg.symbol.info
-          case _ => arg
-        }
         if (tycon1 ne tycon) elim(tycon1.appliedTo(args))
         else tp.derivedAppliedType(tycon, args.map(mapArg))
+      case tp: AndOrType =>
+        // scalajs.js.|.UnionOps has a type parameter upper-bounded by `_ | _`
+        tp.derivedAndOrType(mapArg(tp.tp1).bounds.hi, mapArg(tp.tp2).bounds.hi)
       case _ =>
         tp
     }
@@ -777,6 +781,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         val tycon = select(pre, sym)
         val args = until(end, () => readTypeRef())
         if (sym == defn.ByNameParamClass2x) ExprType(args.head)
+        else if (ctx.settings.scalajs.value && args.length == 2 &&
+            sym.owner == JSDefinitions.jsdefn.ScalaJSJSPackageClass && sym == JSDefinitions.jsdefn.PseudoUnionClass) {
+          // Treat Scala.js pseudo-unions as real unions, this requires a
+          // special-case in erasure, see TypeErasure#eraseInfo.
+          OrType(args(0), args(1), soft = false)
+        }
         else if (args.nonEmpty) tycon.safeAppliedTo(EtaExpandIfHK(sym.typeParams, args.map(translateTempPoly)))
         else if (sym.typeParams.nonEmpty) tycon.EtaExpand(sym.typeParams)
         else tycon

project/Build.scala

@@ -1105,9 +1105,12 @@ object Build {
             -- "ObjectTest.scala" // compile errors caused by #9588
             -- "StackTraceTest.scala" // would require `npm install source-map-support`
             -- "UnionTypeTest.scala" // requires the Scala 2 macro defined in Typechecking*.scala
+            -- "PromiseMock.scala" -- "AsyncTest.scala" // TODO: Enable once we use a Scala.js with https://github.com/scala-js/scala-js/pull/4451 in
             )).get
 
-          ++ (dir / "js/src/test/require-2.12" ** "*.scala").get
+          ++ (dir / "js/src/test/require-2.12" ** (("*.scala": FileFilter)
+            -- "JSOptionalTest212.scala" // TODO: Enable once we use a Scala.js with https://github.com/scala-js/scala-js/pull/4451 in
+            )).get
           ++ (dir / "js/src/test/require-sam" ** "*.scala").get
           ++ (dir / "js/src/test/scala-new-collections" ** "*.scala").get
         )

sbt-dotty/sbt-test/scala2-compat/erasure-scalajs/build.sbt

@@ -0,0 +1,16 @@
+lazy val scala2Lib = project.in(file("scala2Lib"))
+  .enablePlugins(ScalaJSPlugin)
+  .settings(
+    // TODO: switch to 2.13.5 once we've upgrade sbt-scalajs to 1.5.0
+    scalaVersion := "2.13.4"
+  )
+
+lazy val dottyApp = project.in(file("dottyApp"))
+  .dependsOn(scala2Lib)
+  .enablePlugins(ScalaJSPlugin)
+  .settings(
+    scalaVersion := sys.props("plugin.scalaVersion"),
+
+    scalaJSUseMainModuleInitializer := true,
+    scalaJSLinkerConfig ~= (_.withCheckIR(true)),
+  )

sbt-dotty/sbt-test/scala2-compat/erasure-scalajs/dottyApp/Main.scala

@@ -0,0 +1,13 @@
+object Main {
+  def main(args: Array[String]): Unit = {
+    val a = new scala2Lib.A
+    assert(a.foo(1) == "1")
+    assert(a.foo("") == "1")
+    assert(a.foo(Array(1)) == "2")
+
+    val b = new scala2Lib.B
+    assert(b.foo(1) == "1")
+    assert(b.foo("") == "1")
+    assert(b.foo(Array(1)) == "2")
+  }
+}

sbt-dotty/sbt-test/scala2-compat/erasure-scalajs/project/plugins.sbt

@@ -0,0 +1,2 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % sys.props("plugin.version"))
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % sys.props("plugin.scalaJSVersion"))

sbt-dotty/sbt-test/scala2-compat/erasure-scalajs/scala2Lib/Api.scala

@@ -0,0 +1,15 @@
+// Keep synchronized with dottyApp/Api.scala
+package scala2Lib
+
+import scala.scalajs.js
+import js.|
+
+class A {
+  def foo(x: Int | String): String = "1"
+  def foo(x: Array[Int]): String = "2"
+}
+
+class B extends js.Object {
+  def foo(x: Int | String): String = "1"
+  def foo(x: Array[Int]): String = "2"
+}

sbt-dotty/sbt-test/scala2-compat/erasure-scalajs/test

@@ -0,0 +1 @@
+> dottyApp/run

tests/neg-scalajs/js-trait-members-wrong-kind.check

@@ -2,15 +2,15 @@
 5 |  lazy val a1: js.UndefOr[Int] = js.undefined // error
   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |  A non-native JS trait cannot contain lazy vals
--- Error: tests/neg-scalajs/js-trait-members-wrong-kind.scala:7:29 -----------------------------------------------------
+-- Error: tests/neg-scalajs/js-trait-members-wrong-kind.scala:7:32 -----------------------------------------------------
 7 |  def a(): js.UndefOr[Int] = js.undefined // error
   |                             ^^^^^^^^^^^^
   |                             In non-native JS traits, defs with parentheses must be abstract.
--- Error: tests/neg-scalajs/js-trait-members-wrong-kind.scala:8:35 -----------------------------------------------------
+-- Error: tests/neg-scalajs/js-trait-members-wrong-kind.scala:8:38 -----------------------------------------------------
 8 |  def b(x: Int): js.UndefOr[Int] = js.undefined // error
   |                                   ^^^^^^^^^^^^
   |                                   In non-native JS traits, defs with parentheses must be abstract.
--- Error: tests/neg-scalajs/js-trait-members-wrong-kind.scala:9:26 -----------------------------------------------------
+-- Error: tests/neg-scalajs/js-trait-members-wrong-kind.scala:9:29 -----------------------------------------------------
 9 |  def c_=(v: Int): Unit = js.undefined // error
   |                          ^^^^^^^^^^^^
   |                          In non-native JS traits, defs with parentheses must be abstract.