Check for FromJavaObject in -Ytest-pickler

Author: bishabosha

compiler/src/dotty/tools/dotc/printing/OutlinePrinter.scala

@@ -0,0 +1,39 @@
+package dotty.tools
+package dotc
+package printing
+
+import core.*
+import Texts.*
+import Flags.*
+import NameOps.*
+import StdNames.*
+import Contexts.*
+import Symbols.*
+import ast.{Trees, untpd}
+import Trees.*
+
+object OutlinePrinter:
+  def apply(_ctx: Context): Printer = new OutlinePrinter(_ctx)
+
+/** A printer that elides known standard tree forms from the rhs of def and val.
+  * Typically used for printing Java trees which elide the rhs.
+  */
+class OutlinePrinter private (_ctx: Context) extends RefinedPrinter(_ctx) {
+
+  /* Typical patterns seen in output of typer for Java code, plus the output of unpickling an ELIDED tree */
+  def isElidableExpr[T <: Untyped](tree: Tree[T]): Boolean = tree match {
+    case tree: Ident[T] if tree.name == nme.WILDCARD => true
+    case tree: Select[T] if tree.symbol == defn.Predef_undefined => true
+    case Apply(Select(tree: New[T], nme.CONSTRUCTOR), Nil) if tree.tpt.typeOpt.typeSymbol.is(Module) => true
+    case _ => false
+  }
+
+  def elideExpr[T <: Untyped](tree: Tree[T], original: => Text): Text =
+    if isElidableExpr(tree) then Str("_") else original
+
+  override protected def rhsValDef[T <: Untyped](rhs: Tree[T], original: => Text): Text =
+    elideExpr(rhs, original)
+
+  override protected def rhsDefDef[T <: Untyped](rhs: Tree[T], original: => Text): Text =
+    elideExpr(rhs, original)
+}

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -29,6 +29,8 @@ import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
 import cc.{CaptureSet, CapturingType, toCaptureSet, IllegalCaptureRef}
 
+import scala.annotation.unused
+
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   /** A stack of enclosing DefDef, TypeDef, or ClassDef, or ModuleDefs nodes */
@@ -920,7 +922,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     dclTextOr(tree) {
       modText(tree.mods, tree.symbol, keywordStr(if (tree.mods.is(Mutable)) "var" else "val"), isType = false) ~~
         valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
-        withEnclosingDef(tree) { optText(tree.rhs)(" = " ~ _) }
+        withEnclosingDef(tree) { optText(tree.rhs)(rhs => " = " ~ rhsValDef(tree.rhs, rhs)) }
     }
   }
 
@@ -977,11 +979,20 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
         coreSig
         ~ optAscription(tree.tpt)
-        ~ optText(tree.rhs)(" = " ~ keywordText("macro ").provided(tree.symbol.isScala2Macro) ~ _)
+        ~ optText(tree.rhs)(rhs =>
+            " = " ~ rhsDefDef(tree.rhs, keywordText("macro ").provided(tree.symbol.isScala2Macro) ~ rhs))
       }
     }
   }
 
+  /** Inspect the rhs of a ValDef, overridden in OutlinePrinter */
+  protected def rhsValDef[T <: Untyped](@unused("override may inspect rhs") rhs: Tree[T], original: => Text): Text =
+    original
+
+  /** Inspect the rhs of a DefDef, overridden in OutlinePrinter */
+  protected def rhsDefDef[T <: Untyped](@unused("override may inspect rhs") rhs: Tree[T], original: => Text): Text =
+    original
+
   protected def toTextTemplate(impl: Template, ofNew: Boolean = false): Text = {
     val Template(constr @ DefDef(_, paramss, _, _), _, self, _) = impl
     val tparamsTxt = withEnclosingDef(constr) {

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

@@ -10,7 +10,7 @@ import config.Printers.{noPrinter, pickling}
 import config.Feature
 import java.io.PrintStream
 import io.ClassfileWriterOps
-import StdNames.str
+import StdNames.{str, nme}
 import Periods.*
 import Phases.*
 import Symbols.*
@@ -20,6 +20,7 @@ import collection.mutable
 import util.concurrent.{Executor, Future}
 import compiletime.uninitialized
 import dotty.tools.io.JarArchive
+import dotty.tools.dotc.printing.OutlinePrinter
 
 object Pickler {
   val name: String = "pickler"
@@ -86,6 +87,15 @@ class Pickler extends Phase {
     Pickler.ParallelPickling && !ctx.settings.YtestPickler.value &&
     !ctx.settings.YjavaTasty.value // disable parallel pickling when `-Yjava-tasty` is set (internal testing only)
 
+  private def adjustPrinter(ictx: Context): Context =
+    if ictx.compilationUnit.typedAsJava then
+      // use special printer because Java parser will use `Predef.???` as rhs,
+      // which conflicts with the unpickling of ELIDED as `Ident(nme.WILDCARD).withType(tpe)`
+      // In the future we could modify the typer/parser to elide the rhs in the same way.
+      ictx.fresh.setPrinterFn(OutlinePrinter(_))
+    else
+      ictx
+
   override def run(using Context): Unit = {
     val unit = ctx.compilationUnit
     pickling.println(i"unpickling in run ${ctx.runId}")
@@ -94,7 +104,8 @@ class Pickler extends Phase {
       cls <- dropCompanionModuleClasses(topLevelClasses(unit.tpdTree))
       tree <- sliceTopLevel(unit.tpdTree, cls)
     do
-      if ctx.settings.YtestPickler.value then beforePickling(cls) = tree.show
+      if ctx.settings.YtestPickler.value then
+        beforePickling(cls) = tree.show(using adjustPrinter(ctx))
 
       val sourceRelativePath =
         val reference = ctx.settings.sourceroot.value
@@ -242,11 +253,14 @@ class Pickler extends Phase {
     pickling.println("************* entered toplevel ***********")
     val rootCtx = ctx
     for ((cls, (unit, unpickler)) <- unpicklers) do
+      if unit.typedAsJava then
+        if unpickler.unpickler.nameAtRef.contents.exists(_ == nme.FromJavaObject) then
+          report.error(em"Pickled reference to FromJavaObject in Java defined $cls in ${cls.source}")
       val unpickled = unpickler.rootTrees
       val freshUnit = CompilationUnit(rootCtx.compilationUnit.source)
       freshUnit.needsCaptureChecking = unit.needsCaptureChecking
       freshUnit.knowsPureFuns = unit.knowsPureFuns
-      inContext(rootCtx.fresh.setCompilationUnit(freshUnit)):
+      inContext(adjustPrinter(rootCtx.fresh.setCompilationUnit(freshUnit))):
         testSame(i"$unpickled%\n%", beforePickling(cls), cls)
 
   private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(using Context) =

sbt-test/pipelining/Yjava-tasty-fromjavaobject/a-check/.keep

@@ -7,6 +7,17 @@ lazy val a = project.in(file("a"))
     Compile / classDirectory := ((ThisBuild / baseDirectory).value / "a-enum-classes"), // send classfiles to a different directory
   )
 
+// compiles the same sources as a, but with -Ytest-pickler
+lazy val aCheck = project.in(file("a-check"))
+  .settings(
+    scalacOptions += "-Ytest-pickler", // check that the pickler is correct
+    Compile / sources := (a / Compile / sources).value, // use the same sources as a
+    compileOrder := CompileOrder.Mixed, // ensure we send java sources to Scala compiler
+    scalacOptions += "-Yjava-tasty", // enable pickling of java signatures
+    scalacOptions ++= Seq("-Yjava-tasty-output", ((ThisBuild / baseDirectory).value / "a-enum-java-tasty-2.jar").toString),
+    Compile / classDirectory := ((ThisBuild / baseDirectory).value / "a-enum-classes-2"), // send classfiles to a different directory
+  )
+
 
 lazy val b = project.in(file("b"))
   .settings(

sbt-test/pipelining/Yjava-tasty-fromjavaobject/build.sbt

@@ -1,4 +1,7 @@
+# compile Java sources, and send them to TASTy
 > a/compile
+# compile Java sources, and check that they are pickled correctly
+> aCheck/compile
 # test depending on a java compiled enum through TASTy
 > b/run
 # double check against the real java classes