Scala.js: Implement support for linkTimeIf.

This commit is a forward port of the compiler changes in
scala-js/scala-js@5e842d8

Author: sjrd

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

@@ -4103,6 +4103,16 @@ class JSCodeGen()(using genCtx: Context) {
         js.UnaryOp(js.UnaryOp.UnwrapFromThrowable,
             js.UnaryOp(js.UnaryOp.CheckNotNull, genArgs1))
 
+      case LINKTIME_IF =>
+        // LinkingInfo.linkTimeIf(cond, thenp, elsep)
+        val cond = genLinkTimeExpr(args(0))
+        val thenp = genExpr(args(1))
+        val elsep = genExpr(args(2))
+        val tpe =
+          if (isStat) jstpe.VoidType
+          else toIRType(tree.tpe)
+        js.LinkTimeIf(cond, thenp, elsep)(tpe)
+
       case UNION_FROM | UNION_FROM_TYPE_CONSTRUCTOR =>
         /* js.|.from and js.|.fromTypeConstructor
          * We should not have to deal with those. They have a perfectly valid
@@ -4128,6 +4138,91 @@ class JSCodeGen()(using genCtx: Context) {
     }
   }
 
+  private def genLinkTimeExpr(tree: Tree): js.Tree = {
+    import dotty.tools.backend.ScalaPrimitivesOps.*
+
+    import primitives.*
+
+    implicit val pos = tree.span
+
+    def invalid(): js.Tree = {
+      report.error(
+          "Illegal expression in the condition of a linkTimeIf. " +
+          "Valid expressions are: boolean and int primitives; " +
+          "references to link-time properties; " +
+          "primitive operations on booleans; " +
+          "and comparisons on ints.",
+          tree.sourcePos)
+      js.BooleanLiteral(false)
+    }
+
+    tree match {
+      case Literal(c) =>
+        import Constants.*
+        c.tag match {
+          case BooleanTag => js.BooleanLiteral(c.booleanValue)
+          case IntTag     => js.IntLiteral(c.intValue)
+          case _          => invalid()
+        }
+
+      case Apply(fun, args) =>
+        fun.symbol.getAnnotation(jsdefn.LinkTimePropertyAnnot) match {
+          case Some(annotation) =>
+            val propName = annotation.argumentConstantString(0).get
+            js.LinkTimeProperty(propName)(toIRType(tree.tpe))
+
+          case None if isPrimitive(fun.symbol) =>
+            val code = getPrimitive(fun.symbol)
+            val receiver = (fun: @unchecked) match {
+              case fun: Select => fun.qualifier
+              case fun: Ident  => desugarIdent(fun).get.qualifier
+            }
+
+            def genLhs: js.Tree = genLinkTimeExpr(receiver)
+            def genRhs: js.Tree = genLinkTimeExpr(args.head)
+
+            def unaryOp(op: js.UnaryOp.Code): js.Tree =
+              js.UnaryOp(op, genLhs)
+            def binaryOp(op: js.BinaryOp.Code): js.Tree =
+              js.BinaryOp(op, genLhs, genRhs)
+
+            toIRType(receiver.tpe) match {
+              case jstpe.BooleanType =>
+                (code: @switch) match {
+                  case ZNOT     => unaryOp(js.UnaryOp.Boolean_!)
+                  case EQ       => binaryOp(js.BinaryOp.Boolean_==)
+                  case NE | XOR => binaryOp(js.BinaryOp.Boolean_!=)
+                  case OR       => binaryOp(js.BinaryOp.Boolean_|)
+                  case AND      => binaryOp(js.BinaryOp.Boolean_&)
+                  case ZOR      => js.LinkTimeIf(genLhs, js.BooleanLiteral(true), genRhs)(jstpe.BooleanType)
+                  case ZAND     => js.LinkTimeIf(genLhs, genRhs, js.BooleanLiteral(false))(jstpe.BooleanType)
+                  case _        => invalid()
+                }
+
+              case jstpe.IntType =>
+                (code: @switch) match {
+                  case EQ => binaryOp(js.BinaryOp.Int_==)
+                  case NE => binaryOp(js.BinaryOp.Int_!=)
+                  case LT => binaryOp(js.BinaryOp.Int_<)
+                  case LE => binaryOp(js.BinaryOp.Int_<=)
+                  case GT => binaryOp(js.BinaryOp.Int_>)
+                  case GE => binaryOp(js.BinaryOp.Int_>=)
+                  case _  => invalid()
+                }
+
+              case _ =>
+                invalid()
+            }
+
+          case None => // if !isPrimitive
+            invalid()
+        }
+
+      case _ =>
+        invalid()
+    }
+  }
+
   /** Gen the SJSIR for a reflective call.
    *
    *  Reflective calls are calls to a structural type field or method that

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

@@ -215,6 +215,14 @@ final class JSDefinitions()(using Context) {
   @threadUnsafe lazy val WrappedArrayType: TypeRef = requiredClassRef("scala.scalajs.js.WrappedArray")
   def WrappedArrayClass(using Context) = WrappedArrayType.symbol.asClass
 
+  @threadUnsafe lazy val LinkingInfoModuleRef = requiredModuleRef("scala.scalajs.LinkingInfo")
+  def LinkingInfoModule(using Context) = LinkingInfoModuleRef.symbol
+    @threadUnsafe lazy val LinkingInfo_linkTimeIfR = LinkingInfoModule.requiredMethodRef("linkTimeIf")
+    def LinkingInfo_linkTimeIf(using Context) = LinkingInfo_linkTimeIfR.symbol
+
+  @threadUnsafe lazy val LinkTimePropertyAnnotType: TypeRef = requiredClassRef("scala.scalajs.annotation.linkTimeProperty")
+  def LinkTimePropertyAnnot(using Context) = LinkTimePropertyAnnotType.symbol.asClass
+
   @threadUnsafe lazy val ScalaRunTime_isArrayR = defn.ScalaRuntimeModule.requiredMethodRef("isArray", List(???, ???))
   def ScalaRunTime_isArray(using Context): Symbol = ScalaRunTime_isArrayR.symbol
 

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

@@ -47,8 +47,10 @@ object JSPrimitives {
   inline val UNWRAP_FROM_THROWABLE = WRAP_AS_THROWABLE + 1 // js.special.unwrapFromThrowable
   inline val DEBUGGER = UNWRAP_FROM_THROWABLE + 1          // js.special.debugger
 
-  inline val THROW = DEBUGGER + 1  // <special-ops>.throw
-  inline val NEW_ARRAY = THROW + 1 // scala.runtime.Arrays.newArray
+  inline val LINKTIME_IF = DEBUGGER + 1 // LinkingInfo.linkTimeIf
+
+  inline val THROW = LINKTIME_IF + 1 // <special-ops>.throw
+  inline val NEW_ARRAY = THROW + 1   // scala.runtime.Arrays.newArray
 
   inline val UNION_FROM = NEW_ARRAY + 1                   // js.|.from
   inline val UNION_FROM_TYPE_CONSTRUCTOR = UNION_FROM + 1 // js.|.fromTypeConstructor
@@ -135,6 +137,8 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
     addPrimitive(jsdefn.Special_unwrapFromThrowable, UNWRAP_FROM_THROWABLE)
     addPrimitive(jsdefn.Special_debugger, DEBUGGER)
 
+    addPrimitive(jsdefn.LinkingInfo_linkTimeIf, LINKTIME_IF)
+
     addPrimitive(defn.throwMethod, THROW)
     addPrimitive(defn.newArrayMethod, NEW_ARRAY)
 

project/Build.scala

@@ -2820,7 +2820,6 @@ object Build {
           ++ (dir / "js/src/test/scala" ** (("*.scala": FileFilter)
             -- "StackTraceTest.scala" // would require `npm install source-map-support`
             -- "UnionTypeTest.scala" // requires the Scala 2 macro defined in Typechecking*.scala
-            -- "LinkTimeIfTest.scala" // TODO implement support for linkTimeIf
             )).get
 
           ++ (dir / "js/src/test/require-2.12" ** "*.scala").get