Compile Scala library with Dotty and test its TASTy

Author: nicolasstucki

build.sbt

@@ -10,6 +10,9 @@ val `dotty-library-bootstrapped` = Build.`dotty-library-bootstrapped`
 val `dotty-library-bootstrappedJS` = Build.`dotty-library-bootstrappedJS`
 val `dotty-sbt-bridge` = Build.`dotty-sbt-bridge`
 val `dotty-sbt-bridge-tests` = Build.`dotty-sbt-bridge-tests`
+val `dotty-scala-library` = Build.`dotty-scala-library`
+val `dotty-tasty-inspector-library-test` = Build.`dotty-tasty-inspector-library-test`
+val superBootstrappedSandbox = Build.superBootstrappedSandbox
 val `dotty-staging` = Build.`dotty-staging`
 val `dotty-tasty-inspector` = Build.`dotty-tasty-inspector`
 val `dotty-language-server` = Build.`dotty-language-server`

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

@@ -3266,12 +3266,14 @@ class Typer extends Namer
         // To overcome the current limitation we intercept the call and rewrite it into
         // a call to dotty.internal.StringContext.f which we can implement using the new macros.
         // As the macro is implemented in the bootstrapped library, it can only be used from the bootstrapped compiler.
-        val Apply(TypeApply(Select(sc, _), _), args) = tree
-        val newCall = ref(defn.InternalStringContextMacroModule_f).appliedTo(sc).appliedToArgs(args).withSpan(tree.span)
-        readaptSimplified(Inliner.inlineCall(newCall))
+        // val Apply(TypeApply(Select(sc, _), _), args) = tree
+        // val newCall = ref(defn.InternalStringContextMacroModule_f).appliedTo(sc).appliedToArgs(args).withSpan(tree.span)
+        // readaptSimplified(Inliner.inlineCall(newCall))
+        Literal(Constant("")) // FIXME: intrinsify to be able to compile the scala library from dotty without using macros
       else if (tree.symbol.isScala2Macro &&
                // raw and s are eliminated by the StringInterpolatorOpt phase
               tree.symbol != defn.StringContext_raw &&
+              tree.symbol != defn.StringContext_f &&
               tree.symbol != defn.StringContext_s)
         if (ctx.settings.XignoreScala2Macros.value) {
           report.warning("Scala 2 macro cannot be used in Dotty, this call will crash at runtime. See https://dotty.epfl.ch/docs/reference/dropped-features/macros.html", tree.srcPos.startPos)

dotty-scala-library-from-tasty-tests/test/Test1.scala

@@ -0,0 +1,17 @@
+import org.junit.Test
+import org.junit.Assert._
+
+import scala.quoted._
+
+class Test1 {
+  @Test def test1: Unit =
+    val foo = new scala.tasty.inspector.TastyInspector {
+      def processCompilationUnit(using QuoteContext)(root: qctx.tasty.Tree): Unit =
+        println(root.show)
+    }
+    foo.inspect(System.getProperty("dotty.scala.library"), List("scala.Option"))
+
+    println(new dotty.tools.dotc.Driver)
+
+    // assert(false, System.getProperty("dotty.scala.library"))
+}

project/Build.scala

@@ -817,6 +817,79 @@ object Build {
       javaOptions := (javaOptions in `dotty-compiler-bootstrapped`).value
     )
 
+  lazy val `dotty-scala-library-from-tasty-tests` = project.in(file("dotty-scala-library-from-tasty-tests")).
+    withCommonSettings(Bootstrapped).
+    dependsOn(`dotty-tasty-inspector` % "test->test").
+    settings(commonBootstrappedSettings).
+    settings(
+      javaOptions := (javaOptions in `dotty-compiler-bootstrapped`).value,
+      javaOptions += "-Ddotty.scala.library=" + packageBin.in(`dotty-scala-library`, Compile).value.getAbsolutePath
+    )
+
+
+  // Scala library compiled by dotty using the latest published sources of the library
+  lazy val `dotty-scala-library` = project.in(file("dotty-scala-library")).
+    withCommonSettings(Bootstrapped).
+    dependsOn(dottyCompiler(Bootstrapped) % "provided; compile->runtime; test->test").
+    dependsOn(`dotty-tasty-inspector` % "test->test").
+    settings(commonBootstrappedSettings).
+    settings(
+      javaOptions := (javaOptions in `dotty-compiler-bootstrapped`).value,
+      scalacOptions -= "-Xfatal-warnings",
+      /* Add the sources of scalajs-ir.
+       * To guarantee that dotty can bootstrap without depending on a version
+       * of scalajs-ir built with a different Scala compiler, we add its
+       * sources instead of depending on the binaries.
+       */
+      ivyConfigurations += SourceDeps.hide,
+      transitiveClassifiers := Seq("sources"),
+      libraryDependencies +=
+        ("org.scala-lang" % "scala-library" % stdlibVersion(Bootstrapped) % "sourcedeps"),
+      sourceGenerators in Compile += Def.task { // TODO factor out common logic with scalajs
+        val s = streams.value
+        val cacheDir = s.cacheDirectory
+        val trgDir = (sourceManaged in Compile).value / "scala-library-src"
+
+        val report = updateClassifiers.value
+        val scalaLibrarySourcesJar = report.select(
+            configuration = configurationFilter("sourcedeps"),
+            module = (_: ModuleID).name == "scala-library",
+            artifact = artifactFilter(`type` = "src")).headOption.getOrElse {
+          sys.error(s"Could not fetch scala-library sources")
+        }
+
+        FileFunction.cached(cacheDir / s"fetchScalaLibrarySrc",
+            FilesInfo.lastModified, FilesInfo.exists) { dependencies =>
+          s.log.info(s"Unpacking scala-library sources to $trgDir...")
+          if (trgDir.exists)
+            IO.delete(trgDir)
+          IO.createDirectory(trgDir)
+          IO.unzip(scalaLibrarySourcesJar, trgDir)
+
+          ((trgDir ** "*.scala") +++ (trgDir ** "*.java")).get.toSet
+        } (Set(scalaLibrarySourcesJar)).toSeq
+      }.taskValue,
+      sources in Compile ~= (_.filterNot(file => // TODO more efficient filter
+        file.getPath.endsWith("scala/Any.scala") ||
+        file.getPath.endsWith("scala/AnyVal.scala") ||
+        file.getPath.endsWith("scala/AnyRef.scala") ||
+        file.getPath.endsWith("scala/Nothing.scala") ||
+        file.getPath.endsWith("scala/Null.scala") ||
+        file.getPath.endsWith("scala/Singleton.scala")))
+    )
+
+  // TODO rename?
+  // Tests that we can compile and run an app using the scala-library compiled by dotty
+  lazy val superBootstrappedSandbox = project.in(file("sandbox/superbootstrapped")).
+    withCommonSettings(Bootstrapped).
+    dependsOn(`dotty-scala-library`).
+    settings(
+      managedClasspath in Compile ~= {
+        _.filterNot(file => file.data.getName == "scala-library-2.13.3.jar")
+      }
+    )
+
+
   lazy val `dotty-sbt-bridge` = project.in(file("sbt-bridge/src")).
     // We cannot depend on any bootstrapped project to compile the bridge, since the
     // bridge is needed to compile these projects.

sandbox/superbootstrapped/src/hello.scala

@@ -0,0 +1,12 @@
+package hello
+
+enum Color:
+  case Red, Green, Blue
+
+object HelloWorld:
+  def main(args: Array[String]): Unit = {
+    println("hello dotty.superbootstrapped!")
+    println(Color.Red)
+    println(Color.Green)
+    println(Color.Blue)
+  }