Scala.js: Implement the PrepJSInterop phase, minus exports handling.

The `PrepJSInterop` phase is responsible for:

* Performing all kinds of Scala.js-specific compile-time checks,
  and emitting the appropriate compile errors.
* Perform some transformations that are necessary for JavaScript
  interop, notably generating exports forwarders.

This commit ports all the functionality of `PrepJSInterop` from
Scala 2, except the following:

* Handling of `scala.Enumeration`s: it is unclear whether we still
  want to support that in the core, or if it should be handled by
  an optional compiler plugin in the future.
* Exports: they will be done later.
* Warnings about duplicate fields in `js.Dynamic.literal`: mostly
  because they are non-essential.

The test cases are ported from the Scala.js compiler tests.

Author: sjrd

compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala

@@ -36,6 +36,8 @@ final class JSDefinitions()(using Context) {
     def JSPackage_constructorOf(using Context) = JSPackage_constructorOfR.symbol
     @threadUnsafe lazy val JSPackage_nativeR = ScalaJSJSPackageClass.requiredMethodRef("native")
     def JSPackage_native(using Context) = JSPackage_nativeR.symbol
+    @threadUnsafe lazy val JSPackage_undefinedR = ScalaJSJSPackageClass.requiredMethodRef("undefined")
+    def JSPackage_undefined(using Context) = JSPackage_undefinedR.symbol
 
   @threadUnsafe lazy val JSNativeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.native")
   def JSNativeAnnot(using Context) = JSNativeAnnotType.symbol.asClass
@@ -63,6 +65,10 @@ final class JSDefinitions()(using Context) {
   @threadUnsafe lazy val JavaScriptExceptionType: TypeRef = requiredClassRef("scala.scalajs.js.JavaScriptException")
   def JavaScriptExceptionClass(using Context) = JavaScriptExceptionType.symbol.asClass
 
+  @threadUnsafe lazy val JSGlobalAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSGlobal")
+  def JSGlobalAnnot(using Context) = JSGlobalAnnotType.symbol.asClass
+  @threadUnsafe lazy val JSImportAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSImport")
+  def JSImportAnnot(using Context) = JSImportAnnotType.symbol.asClass
   @threadUnsafe lazy val JSGlobalScopeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSGlobalScope")
   def JSGlobalScopeAnnot(using Context) = JSGlobalScopeAnnotType.symbol.asClass
   @threadUnsafe lazy val JSNameAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSName")
@@ -73,21 +79,24 @@ final class JSDefinitions()(using Context) {
   def JSBracketAccessAnnot(using Context) = JSBracketAccessAnnotType.symbol.asClass
   @threadUnsafe lazy val JSBracketCallAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSBracketCall")
   def JSBracketCallAnnot(using Context) = JSBracketCallAnnotType.symbol.asClass
+  @threadUnsafe lazy val JSExportTopLevelAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportTopLevel")
+  def JSExportTopLevelAnnot(using Context) = JSExportTopLevelAnnotType.symbol.asClass
   @threadUnsafe lazy val JSExportAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExport")
   def JSExportAnnot(using Context) = JSExportAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportDescendentObjectsAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportDescendentObjects")
-  def JSExportDescendentObjectsAnnot(using Context) = JSExportDescendentObjectsAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportDescendentClassesAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportDescendentClasses")
-  def JSExportDescendentClassesAnnot(using Context) = JSExportDescendentClassesAnnotType.symbol.asClass
+  @threadUnsafe lazy val JSExportStaticAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportStatic")
+  def JSExportStaticAnnot(using Context) = JSExportStaticAnnotType.symbol.asClass
   @threadUnsafe lazy val JSExportAllAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportAll")
   def JSExportAllAnnot(using Context) = JSExportAllAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportNamedAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportNamed")
-  def JSExportNamedAnnot(using Context) = JSExportNamedAnnotType.symbol.asClass
-  @threadUnsafe lazy val RawJSTypeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.RawJSType")
-  def RawJSTypeAnnot(using Context) = RawJSTypeAnnotType.symbol.asClass
-  @threadUnsafe lazy val ExposedJSMemberAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.ExposedJSMember")
+  @threadUnsafe lazy val JSTypeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.internal.JSType")
+  def JSTypeAnnot(using Context) = JSTypeAnnotType.symbol.asClass
+  @threadUnsafe lazy val JSOptionalAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.internal.JSOptional")
+  def JSOptionalAnnot(using Context) = JSOptionalAnnotType.symbol.asClass
+  @threadUnsafe lazy val ExposedJSMemberAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.internal.ExposedJSMember")
   def ExposedJSMemberAnnot(using Context) = ExposedJSMemberAnnotType.symbol.asClass
 
+  @threadUnsafe lazy val JSImportNamespaceModuleRef = requiredModuleRef("scala.scalajs.js.annotation.JSImport.Namespace")
+  def JSImportNamespaceModule(using Context) = JSImportNamespaceModuleRef.symbol
+
   @threadUnsafe lazy val JSAnyModuleRef = requiredModuleRef("scala.scalajs.js.Any")
   def JSAnyModule(using Context) = JSAnyModuleRef.symbol
     @threadUnsafe lazy val JSAny_fromFunctionR = (0 to 22).map(n => JSAnyModule.requiredMethodRef("fromFunction" + n)).toArray

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -41,6 +41,7 @@ class Compiler {
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
     List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
+    List(new sjs.PrepJSInterop) ::  // Additional checks and transformations for Scala.js (Scala.js only)
     List(new Staging) ::            // Check PCP, heal quoted types and expand macros
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
     List(new SetRootTree) ::        // Set the `rootTreeOrProvider` on class symbols

compiler/src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -61,6 +61,9 @@ class JavaPlatform extends Platform {
     (sym derivesFrom BoxedBooleanClass)
   }
 
+  def shouldReceiveJavaSerializationMethods(sym: ClassSymbol)(using Context): Boolean =
+    true
+
   def newClassLoader(bin: AbstractFile)(using Context): SymbolLoader =
     new ClassfileLoader(bin)
 }

compiler/src/dotty/tools/dotc/config/Platform.scala

@@ -31,6 +31,9 @@ abstract class Platform {
   /** The various ways a boxed primitive might materialize at runtime. */
   def isMaybeBoxed(sym: ClassSymbol)(using Context): Boolean
 
+  /** Is the given class symbol eligible for Java serialization-specific methods? */
+  def shouldReceiveJavaSerializationMethods(sym: ClassSymbol)(using Context): Boolean
+
   /** Create a new class loader to load class file `bin` */
   def newClassLoader(bin: AbstractFile)(using Context): SymbolLoader
 
@@ -44,4 +47,3 @@ abstract class Platform {
       case _ => false
     }
 }
-

compiler/src/dotty/tools/dotc/config/SJSPlatform.scala

@@ -3,9 +3,18 @@ package dotty.tools.dotc.config
 import dotty.tools.dotc.core._
 import Contexts._
 import Symbols._
+import SymDenotations._
 
 import dotty.tools.backend.sjs.JSDefinitions
 
+import org.scalajs.ir.Trees.JSNativeLoadSpec
+
+object SJSPlatform {
+  /** The `SJSPlatform` for the current context. */
+  def sjsPlatform(using Context): SJSPlatform =
+    ctx.platform.asInstanceOf[SJSPlatform]
+}
+
 class SJSPlatform()(using Context) extends JavaPlatform {
 
   /** Scala.js-specific definitions. */
@@ -16,4 +25,27 @@ class SJSPlatform()(using Context) extends JavaPlatform {
     defn.isFunctionClass(cls)
       || jsDefinitions.isJSFunctionClass(cls)
       || jsDefinitions.isJSThisFunctionClass(cls)
+
+  override def shouldReceiveJavaSerializationMethods(sym: ClassSymbol)(using Context): Boolean =
+    !sym.isSubClass(jsDefinitions.JSAnyClass)
+
+  object perRunInfo {
+    private val jsNativeLoadSpecs = new MutableSymbolMap[JSNativeLoadSpec]
+
+    /** Clears all the info at the beginning of a run. */
+    def clear(): Unit =
+      jsNativeLoadSpecs.clear()
+
+    /** Stores the JS native load spec of a symbol for the current compilation run. */
+    def storeJSNativeLoadSpec(sym: Symbol, spec: JSNativeLoadSpec): Unit =
+      jsNativeLoadSpecs(sym) = spec
+
+    /** Gets the JS native load spec of a symbol in the current compilation run. */
+    def jsNativeLoadSpecOf(sym: Symbol): JSNativeLoadSpec =
+      jsNativeLoadSpecs(sym)
+
+    /** Gets the JS native load spec of a symbol in the current compilation run, if it has one. */
+    def jsNativeLoadSpecOfOption(sym: Symbol): Option[JSNativeLoadSpec] =
+      jsNativeLoadSpecs.get(sym)
+  }
 }

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

@@ -33,7 +33,10 @@ object Annotations {
       if (i < args.length) Some(args(i)) else None
     }
     def argumentConstant(i: Int)(using Context): Option[Constant] =
-      for (ConstantType(c) <- argument(i) map (_.tpe)) yield c
+      for (ConstantType(c) <- argument(i) map (_.tpe.widenTermRefExpr.normalized)) yield c
+
+    def constantStringArg(i: Int)(using Context): Option[String] =
+      for (Constant(s: String) <- argumentConstant(i)) yield s
 
     /** The tree evaluaton is in progress. */
     def isEvaluating: Boolean = false

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

@@ -259,6 +259,10 @@ object SymDenotations {
     final def addAnnotation(annot: Annotation): Unit =
       annotations = annot :: myAnnotations
 
+    /** Add the given annotation without parameters to the annotations of this denotation */
+    final def addAnnotation(cls: ClassSymbol)(using Context): Unit =
+      addAnnotation(Annotation(cls))
+
     /** Remove annotation with given class from this denotation */
     final def removeAnnotation(cls: Symbol)(using Context): Unit =
       annotations = myAnnotations.filterNot(_ matches cls)

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -188,11 +188,15 @@ object SymUtils {
   def hasAnonymousChild(using Context): Boolean =
     self.children.exists(_ `eq` self)
 
+  /** Is this symbol directly owner by a term symbol, i.e., is it local to a block? */
+  def isLocalToBlock(using Context): Boolean =
+    self.owner.isTerm
+
   /** Is symbol directly or indirectly owned by a term symbol? */
   @tailrec final def isLocal(using Context): Boolean = {
     val owner = self.maybeOwner
     if (!owner.exists) false
-    else if (owner.isTerm) true
+    else if (isLocalToBlock) true
     else if (owner.is(Package)) false
     else owner.isLocal
   }

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -397,7 +397,11 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
    *  we do that even for objects that are not serializable at this phase.
    */
   def serializableObjectMethod(clazz: ClassSymbol)(using Context): List[Tree] =
-    if clazz.is(Module) && clazz.isStatic && !hasWriteReplace(clazz) then
+    if clazz.is(Module)
+      && clazz.isStatic
+      && !hasWriteReplace(clazz)
+      && ctx.platform.shouldReceiveJavaSerializationMethods(clazz)
+    then
       List(
         DefDef(writeReplaceDef(clazz),
           _ => New(defn.ModuleSerializationProxyClass.typeRef,
@@ -424,6 +428,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
       && !clazz.derivesFrom(defn.JavaEnumClass)
       && clazz.isSerializable
       && !hasReadResolve(clazz)
+      && ctx.platform.shouldReceiveJavaSerializationMethods(clazz)
     then
       List(
         DefDef(readResolveDef(clazz),

compiler/src/dotty/tools/dotc/transform/sjs/JSInteropUtils.scala

@@ -0,0 +1,78 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import core._
+import util.SrcPos
+import Annotations._
+import Constants._
+import Contexts._
+import Decorators._
+import DenotTransformers._
+import Flags._
+import NameOps._
+import Names._
+import Phases._
+import Scopes._
+import StdNames._
+import Symbols._
+import SymDenotations._
+import SymUtils._
+import ast.Trees._
+import Types._
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+object JSInteropUtils {
+  enum JSName {
+    case Literal(name: String)
+    case Computed(sym: Symbol)
+
+    def displayName(using Context): String = this match {
+      case Literal(name) => name
+      case Computed(sym) => sym.fullName.toString()
+    }
+  }
+
+  extension (sym: Symbol) {
+    /** Should this symbol be translated into a JS getter? */
+    def isJSGetter(using Context): Boolean = {
+      sym.is(Module) || (
+          sym.is(Method)
+            && sym.info.firstParamTypes.isEmpty
+            && atPhaseNoLater(erasurePhase)(sym.info.isParameterless))
+    }
+
+    /** Should this symbol be translated into a JS setter? */
+    def isJSSetter(using Context): Boolean =
+      sym.originalName.isSetterName && sym.is(Method)
+
+    /** Should this symbol be translated into a JS bracket access? */
+    def isJSBracketAccess(using Context): Boolean =
+      sym.hasAnnotation(jsdefn.JSBracketAccessAnnot)
+
+    /** Should this symbol be translated into a JS bracket call? */
+    def isJSBracketCall(using Context): Boolean =
+      sym.hasAnnotation(jsdefn.JSBracketCallAnnot)
+
+    /** Gets the unqualified JS name of the symbol.
+     *
+     *  If it is not explicitly specified with an `@JSName` annotation, the
+     *  JS name is inferred from the Scala name.
+     */
+    def jsName(using Context): JSName = {
+      sym.getAnnotation(jsdefn.JSNameAnnot).fold[JSName] {
+        JSName.Literal(defaultJSName)
+      } { annotation =>
+        annotation.arguments.head match {
+          case Literal(Constant(name: String)) => JSName.Literal(name)
+          case tree                            => JSName.Computed(tree.symbol)
+        }
+      }
+    }
+
+    def defaultJSName(using Context): String =
+      if (sym.isTerm) sym.asTerm.name.unexpandedName.getterName.toString()
+      else sym.name.unexpandedName.toString()
+  }
+}

compiler/src/dotty/tools/dotc/transform/sjs/PrepJSExports.scala

@@ -0,0 +1,49 @@
+package dotty.tools.dotc
+package transform
+package sjs
+
+import dotty.tools.dotc.ast.{Trees, tpd, untpd}
+import scala.collection.mutable
+import core._
+import dotty.tools.dotc.typer.Checking
+import dotty.tools.dotc.typer.Inliner
+import dotty.tools.dotc.typer.VarianceChecker
+import Types._
+import Contexts._
+import Names._
+import Flags._
+import DenotTransformers._
+import Phases._
+import SymDenotations._
+import StdNames._
+import Annotations._
+import Trees._
+import Scopes._
+import Decorators._
+import Symbols._
+import SymUtils._
+import NameOps._
+import reporting._
+import util.SrcPos
+
+import dotty.tools.backend.sjs.JSDefinitions.jsdefn
+
+object PrepJSExports {
+  import tpd._
+
+  def registerClassOrModuleExports(sym: Symbol)(using Context): Unit = {
+    // TODO
+  }
+
+  /** Generate the exporter for the given DefDef
+   *  or ValDef (abstract val in class, val in trait or lazy val;
+   *  these don't get DefDefs until the fields phase)
+   *
+   *  If this DefDef is a constructor, it is registered to be exported by
+   *  GenJSCode instead and no trees are returned.
+   */
+  def genExportMember(baseSym: Symbol)(using Context): List[Tree] = {
+    // TODO
+    Nil
+  }
+}