Add partial cross-compilation for Scala 3 (#4549)

Author: adkian-sifive

.github/workflows/test.yml

@@ -90,7 +90,7 @@ jobs:
           $CHISEL_FIRTOOL_PATH/firtool -version >> $GITHUB_STEP_SUMMARY
           echo \`\`\` >> $GITHUB_STEP_SUMMARY
       - name: Test
-        run: ./mill -j0 firrtl[_].test + svsim[_].test + chisel[_].test
+        run: ./mill -j0 firrtl[].test + svsim[].test + chisel[].test
       - name: Binary compatibility
         # TODO either make this also check the plugin or decide that we don't
         #      support binary compatibility for the plugin
@@ -132,7 +132,7 @@ jobs:
           $CHISEL_FIRTOOL_PATH/firtool -version >> $GITHUB_STEP_SUMMARY
           echo \`\`\` >> $GITHUB_STEP_SUMMARY
       - name: Compile with Mill
-        run: ./mill __.compile
+        run: ./mill compileAll
 
   doc:
     name: Formatting
@@ -183,7 +183,7 @@ jobs:
           dir=$(dirname $(which firtool))
           echo "CHISEL_FIRTOOL_PATH=$dir" >> "$GITHUB_ENV"
       - name: Integration Tests
-        run: ./mill -j0 integrationTests[_].test
+        run: ./mill -j0 integrationTests[].test
 
   # Currently just a sanity check that the benchmarking flow works
   benchmark:

build.sc

@@ -34,15 +34,34 @@ object v extends Module {
     val java21Min213 = 11
     val minVersion = if (javaVersion > 11) java21Min213 else 0
     val versions = minVersion to latest213
-    versions.map(v => s"2.13.$v").toSeq
+    val versionSeq = versions.map(v => s"2.13.$v").toSeq
+    versionSeq ++ Seq("3.3.4")
   }
 
   val scalaCrossVersions = Seq(
-    "2.13.15"
+    "2.13.15",
+    "3.3.4"
   )
 
   def isScala3(ver: String): Boolean = ver.startsWith("3.")
 
+  def buildUnits(): Seq[ScalaModule] = {
+    scalaCrossVersions.flatMap { ver =>
+      Seq(chisel(ver), stdlib(ver), unipublish)
+    } ++ scalaCrossVersions.filterNot(isScala3(_)).flatMap { ver2 =>
+      Seq(
+        chisel(ver2).test,
+        firrtl(ver2).test,
+        svsim(ver2).test,
+        integrationTests(ver2).test,
+        litutility(ver2),
+        panamaconverter(ver2),
+        panamalib(ver2),
+        panamaom(ver2)
+      )
+    }
+  }
+
   val scalaVersion = scalaCrossVersions.head
   val jmhVersion = "1.37"
   val osLib = ivy"com.lihaoyi::os-lib:0.10.0"
@@ -96,6 +115,10 @@ object v extends Module {
   )
 }
 
+def compileAll() = T.command {
+  T.traverse(v.buildUnits())(_.compile)()
+}
+
 trait ChiselPublishModule extends CiReleaseModule {
   // Publish information
   def pomSettings = PomSettings(
@@ -251,7 +274,7 @@ trait Core extends CrossSbtModule with HasScala2MacroAnno with ScalafmtModule {
   )
 
   override def ivyDeps = if (v.isScala3(crossScalaVersion)) {
-    super.ivyDeps() ++ commonDeps
+    super.ivyDeps() ++ commonDeps ++ Agg(v.firtoolResolver.withDottyCompat(scalaVersion()))
   } else {
     super.ivyDeps() ++ commonDeps ++ Agg(v.firtoolResolver)
   }
@@ -309,7 +332,13 @@ trait Plugin extends CrossSbtModule with ScalafmtModule with ChiselPublishModule
   def scalaReflectIvy = v.scalaReflect(crossScalaVersion)
   def scalaCompilerIvy: Dep = v.scalaCompiler(crossScalaVersion)
 
-  def ivyDeps = super.ivyDeps() ++ Agg(scalaLibraryIvy, scalaReflectIvy, scalaCompilerIvy)
+  def ivyDeps = T {
+    if (!v.isScala3(crossScalaVersion)) {
+      super.ivyDeps() ++ Agg(scalaLibraryIvy, scalaReflectIvy, scalaCompilerIvy)
+    } else {
+      super.ivyDeps()
+    }
+  }
 }
 
 object chisel extends Cross[Chisel](v.scalaCrossVersions)

core/src/main/scala/chisel3/experimental/SerializableModuleGenerator.scala renamed to core/src/main/scala-2/chisel3/experimental/SerializableModuleGenerator.scala

@@ -27,6 +27,7 @@ import scala.reflect.macros.blackbox.Context
   */
 sealed trait ChiselSubtypeOf[A, B]
 
+// return an empty tree here instead of a quasiquote for scala3 compatibility
 object ChiselSubtypeOf {
   // TODO return an empty tree here instead of a quasiquote for scala3 compatibility
   def genChiselSubtypeOf[A: c.WeakTypeTag, B: c.WeakTypeTag](c: Context): c.Tree = {

core/src/main/scala-2/chisel3/experimental/dataview/ChiselSubtypeOf.scala

@@ -0,0 +1,54 @@
+package chisel3.experimental.hierarchy.core
+
+import chisel3._
+import scala.reflect.runtime.universe.TypeTag
+
+trait HierarchyProto[+A] {
+  private[chisel3] def underlying: Underlying[A]
+  private[chisel3] def proto: A = underlying match {
+    case Proto(value) => value
+    case Clone(i: IsClone[A]) => i.getProto
+  }
+}
+
+trait HierarchyIsA[+A] extends HierarchyProto[A] {
+  // This code handles a special-case where, within an mdoc context, the type returned from
+  //  scala reflection (typetag) looks different than when returned from java reflection.
+  //  This function detects this case and reshapes the string to match.
+  private def modifyReplString(clz: String): String = {
+    if (clz != null) {
+      clz.split('.').toList match {
+        case "repl" :: "MdocSession" :: app :: rest => s"$app.this." + rest.mkString(".")
+        case other                                  => clz
+      }
+    } else clz
+  }
+
+  private lazy val superClasses = calculateSuperClasses(super.proto.getClass())
+  private def calculateSuperClasses(clz: Class[_]): Set[String] = {
+    if (clz != null) {
+      Set(modifyReplString(clz.getCanonicalName())) ++
+        clz.getInterfaces().flatMap(i => calculateSuperClasses(i)) ++
+        calculateSuperClasses(clz.getSuperclass())
+    } else {
+      Set.empty[String]
+    }
+  }
+  private def inBaseClasses(clz: String): Boolean = superClasses.contains(clz)
+
+  /** Determine whether underlying proto is of type provided.
+    *
+    * @note IMPORTANT: this function requires summoning a TypeTag[B], which will fail if B is an inner class.
+    * @note IMPORTANT: this function IGNORES type parameters, akin to normal type erasure.
+    * @note IMPORTANT: this function relies on Java reflection for underlying proto, but Scala reflection for provided type
+    *
+    * E.g. isA[List[Int]] will return true, even if underlying proto is of type List[String]
+    * @return Whether underlying proto is of provided type (with caveats outlined above)
+    */
+  def isA[B: TypeTag]: Boolean = {
+    val tptag = implicitly[TypeTag[B]]
+    // drop any type information for the comparison, because the proto will not have that information.
+    val name = tptag.tpe.toString.takeWhile(_ != '[')
+    inBaseClasses(name)
+  }
+}