wip: undefOr2ops import, more complete erasure

Author: smarter

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

@@ -11,6 +11,8 @@ import collection.mutable
 import Denotations.SingleDenotation
 import util.{SimpleIdentityMap, SourceFile, NoSource}
 import typer.ImportInfo.RootRef
+import ast.untpd
+import backend.sjs.JSDefinitions
 
 import scala.annotation.tailrec
 
@@ -1342,16 +1344,30 @@ class Definitions {
     RootRef(() => ScalaPackageVal.termRef)
 
   private val PredefImportFns: RootRef =
-    RootRef(() => ScalaPredefModule.termRef, isPredef=true)
+    RootRef(() => ScalaPredefModule.termRef,
+      selectors =
+        // do not import any2stringadd
+        untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.Ident(nme.WILDCARD)) ::
+        RootRef.defaultSelectors)
+
+  @tu private lazy val ScalaJsRootImportFn: RootRef =
+    RootRef(() => JSDefinitions.jsdefn.PseudoUnionModuleRef,
+      // import only undefOr2ops
+      selectors = List(untpd.ImportSelector(untpd.Ident(nme.undefOr2ops))))
 
   @tu private lazy val JavaRootImportFns: List[RootRef] =
     if ctx.settings.YnoImports.value then Nil
     else JavaImportFns
 
   @tu private lazy val ScalaRootImportFns: List[RootRef] =
-    if ctx.settings.YnoImports.value then Nil
-    else if ctx.settings.YnoPredef.value then ScalaImportFns
-    else ScalaImportFns :+ PredefImportFns
+    if ctx.settings.YnoImports.value then
+      Nil
+    else if ctx.settings.YnoPredef.value then
+      ScalaImportFns
+    else if !ctx.settings.scalajs.value then
+      ScalaImportFns :+ PredefImportFns
+    else
+      ScalaImportFns :+ PredefImportFns :+ ScalaJsRootImportFn
 
   @tu private lazy val JavaRootImportTypes: List[TermRef] = JavaRootImportFns.map(_.refFn())
   @tu private lazy val ScalaRootImportTypes: List[TermRef] = ScalaRootImportFns.map(_.refFn())

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

@@ -614,6 +614,7 @@ object StdNames {
     val unapply: N              = "unapply"
     val unapplySeq: N           = "unapplySeq"
     val unbox: N                = "unbox"
+    val undefOr2ops: N          = "undefOr2ops"
     val universe: N             = "universe"
     val unsafeNulls: N          = "unsafeNulls"
     val update: N               = "update"

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

@@ -593,7 +593,10 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     val tp1 =
       if sourceLanguage.isScala2 && ctx.settings.scalajs.value then
         val eraseAsPseudoUnion = new TypeMap:
-          def apply(tp: Type) = tp match
+          // TODO: This isn't good enough since an OrType might be
+          // hidden behind a bound for example; we might have no
+          // choice but to move this logic to the TypeErasure class.
+          def apply(tp: Type) = tp.dealias match
             case tp: OrType =>
               JSDefinitions.jsdefn.PseudoUnionType
             case tp =>

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

@@ -17,18 +17,18 @@ import Decorators._
 
 object ImportInfo {
 
-  case class RootRef(refFn: () => TermRef, isPredef: Boolean = false)
-
-  /** The import info for a root import */
-  def rootImport(ref: RootRef)(using Context): ImportInfo =
-    var selectors =
+  case class RootRef(refFn: () => TermRef, selectors: Context ?=> List[untpd.ImportSelector] = Nil)
+  object RootRef:
+    def defaultSelectors(using Context): List[untpd.ImportSelector] =
       untpd.ImportSelector(untpd.Ident(nme.WILDCARD))  // import all normal members...
       :: untpd.ImportSelector(untpd.Ident(nme.EMPTY))  // ... and also all given members
       :: Nil
-    if ref.isPredef then                               // do not import any2stringadd
-      selectors = untpd.ImportSelector(untpd.Ident(nme.any2stringadd), untpd.Ident(nme.WILDCARD))
-        :: selectors
+    def apply(refFn: () => TermRef)(using Context): RootRef =
+      RootRef(refFn, defaultSelectors)
 
+  /** The import info for a root import */
+  def rootImport(ref: RootRef)(using Context): ImportInfo =
+    val selectors = ref.selectors
     def sym(using Context) =
       val expr = tpd.Ident(ref.refFn()) // refFn must be called in the context of ImportInfo.sym
       tpd.Import(expr, selectors).symbol