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.

Unresolved issues:
- 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). Should we add a
  special-case in typer to handle this or can this be fixed on the
  scalajs-library side?
- 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),
  should we just ignore that import in typer?

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._
@@ -570,14 +571,37 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     else defn.TupleXXLClass.typeRef
   }
 
-  /** The erasure of a symbol's info. This is different from `apply` in the way `ExprType`s and
-   *  `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them
-   *  to the underlying type.
+  /** The erasure of a symbol's info. This  is different from `apply` in several ways:
+   *  - `ExprType` and `PolyType` are erased to method types, whereas `apply` erases them
+   *    to the underlying type.
+   *  - context functions are flattened (see `Config.flattenContextFunctionResults`)
+   *  - Unions in Scala2.js symbols are erased to the Scala.js pseudo-union type.
    */
   def eraseInfo(tp: Type, sym: Symbol)(using Context): Type =
-    val tp1 = tp match
+    val tp0 = tp match
       case tp: MethodicType => integrateContextResults(tp, contextResultCount(sym))
       case _ => tp
+
+    // 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.
+    // This logic must be in `eraseInfo` and not `apply`, because a Scala 2 type
+    // which is not the info of a symbol could contain a Scala 3 union after
+    // substitution (e.g. via `asSeenFrom`), and we do not want to erase these
+    // unions specially since it could affect the behavior of
+    // `Denotation#matches`.
+    val tp1 =
+      if sourceLanguage.isScala2 && ctx.settings.scalajs.value then
+        val eraseAsPseudoUnion = new TypeMap:
+          def apply(tp: Type) = tp match
+            case tp: OrType =>
+              JSDefinitions.jsdefn.PseudoUnionType
+            case tp =>
+              mapOver(tp)
+        eraseAsPseudoUnion(tp0)
+      else
+        tp0
+
     tp1 match
       case ExprType(rt) =>
         if sym.is(Param) then apply(tp1)

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
@@ -674,6 +675,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)
@@ -689,12 +694,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
     }
@@ -776,6 +780,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

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