elide fake java primary constructor

introduce SPLITCLAUSE at the end of the template parents,
if present, then there is no primary constructor. We assert
that we have the JAVAattr and reconstruct the fake primary constructor
to satisfy the compiler.

Author: bishabosha

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -361,7 +361,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
         else
           throw ex
     if sym.is(Method) && sym.owner.isClass then
-      profile.recordMethodSize(sym, currentAddr.index - addr.index, mdef.span)
+      profile.recordMethodSize(sym, (currentAddr.index - addr.index) max 1, mdef.span)
     for docCtx <- ctx.docCtx do
       val comment = docCtx.docstrings.lookup(sym)
       if comment != null then
@@ -617,7 +617,17 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
                 }
               }
             }
-            pickleStats(tree.constr :: rest)
+            if isJavaPickle then
+              val rest0 = rest.dropWhile:
+                case stat: ValOrDefDef => stat.symbol.is(Flags.Invisible)
+                case _ => false
+              if tree.constr.symbol.is(Flags.Invisible) then
+                writeByte(SPLITCLAUSE)
+                pickleStats(rest0)
+              else
+                pickleStats(tree.constr :: rest0)
+            else
+              pickleStats(tree.constr :: rest)
           }
         case Import(expr, selectors) =>
           writeByte(IMPORT)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -168,6 +168,11 @@ class TreeUnpickler(reader: TastyReader,
     def forkAt(start: Addr): TreeReader = new TreeReader(subReader(start, endAddr))
     def fork: TreeReader = forkAt(currentAddr)
 
+    def skipParentTree(tag: Int): Unit = {
+      if tag == SPLITCLAUSE then ()
+      else skipTree(tag)
+    }
+    def skipParentTree(): Unit = skipParentTree(readByte())
     def skipTree(tag: Int): Unit = {
       if (tag >= firstLengthTreeTag) goto(readEnd())
       else if (tag >= firstNatASTTreeTag) { readNat(); skipTree() }
@@ -1016,7 +1021,7 @@ class TreeUnpickler(reader: TastyReader,
      *                   parsed in this way as InferredTypeTrees.
      */
     def readParents(withArgs: Boolean)(using Context): List[Tree] =
-      collectWhile(nextByte != SELFDEF && nextByte != DEFDEF) {
+      collectWhile({val tag = nextByte; tag != SELFDEF && tag != DEFDEF && tag != SPLITCLAUSE}) {
         nextUnsharedTag match
           case APPLY | TYPEAPPLY | BLOCK =>
             if withArgs then readTree()
@@ -1043,7 +1048,8 @@ class TreeUnpickler(reader: TastyReader,
       val bodyFlags = {
         val bodyIndexer = fork
         // The first DEFDEF corresponds to the primary constructor
-        while (bodyIndexer.reader.nextByte != DEFDEF) bodyIndexer.skipTree()
+        while ({val tag = bodyIndexer.reader.nextByte; tag != DEFDEF && tag != SPLITCLAUSE}) do
+          bodyIndexer.skipParentTree()
         bodyIndexer.indexStats(end)
       }
       val parentReader = fork
@@ -1062,7 +1068,38 @@ class TreeUnpickler(reader: TastyReader,
           cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,
           selfInfo = if (self.isEmpty) NoType else self.tpt.tpe
         ).integrateOpaqueMembers
-      val constr = readIndexedDef().asInstanceOf[DefDef]
+
+      val (constr, stats0) =
+        if nextByte == SPLITCLAUSE then
+          assert(unpicklingJava, s"unexpected SPLITCLAUSE at $start")
+          val tag = readByte()
+          def ta = ctx.typeAssigner
+          val flags = Flags.JavaDefined | Flags.PrivateLocal | Flags.Invisible
+          val pflags = Flags.JavaDefined | Flags.Param
+          val tdefRefs = tparams.map(_.symbol.asType)
+          val ctorCompleter = new LazyType {
+            def complete(denot: SymDenotation)(using Context) =
+              val sym = denot.symbol
+              lazy val tparamSyms: List[TypeSymbol] = tparams.map: tdef =>
+                val completer = new LazyType {
+                  def complete(denot: SymDenotation)(using Context) =
+                    denot.info = tdef.symbol.asType.info.subst(tdefRefs, tparamSyms.map(_.typeRef))
+                }
+                newSymbol(sym, tdef.name, pflags, completer, coord = cls.coord)
+              val paramSym =
+                newSymbol(sym, nme.syntheticParamName(1), pflags, defn.UnitType, coord = cls.coord)
+              val paramSymss = tparamSyms :: List(paramSym) :: Nil
+              val res = effectiveResultType(sym, paramSymss)
+              denot.info = methodType(paramSymss, res)
+              denot.setParamss(paramSymss)
+          }
+          val ctorSym = newSymbol(ctx.owner, nme.CONSTRUCTOR, flags, ctorCompleter, coord = coordAt(start))
+          val accSym = newSymbol(cls, nme.syntheticParamName(1), flags, defn.UnitType, coord = ctorSym.coord)
+          val ctorDef = tpd.DefDef(ctorSym, EmptyTree)
+          val accessor = tpd.ValDef(accSym, ElidedTree(accSym.info))
+          (ctorDef.setDefTree, accessor.setDefTree :: Nil)
+        else
+          readIndexedDef().asInstanceOf[DefDef] -> Nil
       val mappedParents: LazyTreeList =
         if parents.exists(_.isInstanceOf[InferredTypeTree]) then
           // parents were not read fully, will need to be read again later on demand
@@ -1073,7 +1110,7 @@ class TreeUnpickler(reader: TastyReader,
 
       val lazyStats = readLater(end, rdr => {
         val stats = rdr.readIndexedStats(localDummy, end)
-        tparams ++ vparams ++ stats
+        tparams ++ vparams ++ stats0 ++ stats
       })
       defn.patchStdLibClass(cls)
       NamerOps.addConstructorProxies(cls)
@@ -1183,6 +1220,9 @@ class TreeUnpickler(reader: TastyReader,
 
 // ------ Reading trees -----------------------------------------------------
 
+    private def ElidedTree(tpe: Type)(using Context): Tree =
+      untpd.Ident(nme.WILDCARD).withType(tpe)
+
     def readTree()(using Context): Tree = {
       val sctx = sourceChangeContext()
       if (sctx `ne` ctx) return readTree()(using sctx)
@@ -1239,7 +1279,7 @@ class TreeUnpickler(reader: TastyReader,
             val msg =
               s"Illegal elided tree in unpickler at $start without ${attributeTagToString(OUTLINEattr)}, ${ctx.source}"
             report.error(msg)
-          untpd.Ident(nme.WILDCARD).withType(readType())
+          ElidedTree(readType())
         case IDENTtpt =>
           untpd.Ident(readName().toTypeName).withType(readType())
         case SELECT =>

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -120,10 +120,10 @@ object JavaParsers {
       // can call it.
       // This also avoids clashes between the constructor parameter names and member names.
       if (needsDummyConstr) {
+        val fakeFlags = Flags.JavaDefined | Flags.PrivateLocal | Flags.Invisible
         if (constr1 == EmptyTree) constr1 = makeConstructor(List(), Nil, Parsers.unimplementedExpr)
         stats1 = constr1 :: stats1
-        constr1 =
-          makeConstructor(List(scalaDot(tpnme.Unit)), tparams, EmptyTree, Flags.JavaDefined | Flags.PrivateLocal)
+        constr1 = makeConstructor(List(scalaDot(tpnme.Unit)), tparams, EmptyTree, fakeFlags)
       }
       else if (constr1 == EmptyTree) {
         constr1 = makeConstructor(List(), tparams, EmptyTree)

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

@@ -17,6 +17,7 @@ object OutlinePrinter:
 
 /** 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.
+  * Note that there may still be some differences if you compare before and after pickling.
   */
 class OutlinePrinter private (_ctx: Context) extends RefinedPrinter(_ctx) {
 

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

@@ -87,15 +87,6 @@ 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, isOutline: Boolean): Context =
-    if isOutline 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}")
@@ -104,8 +95,7 @@ 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(using adjustPrinter(ctx, unit.typedAsJava))
+      if ctx.settings.YtestPickler.value then beforePickling(cls) = tree.show
 
       val sourceRelativePath =
         val reference = ctx.settings.sourceroot.value
@@ -256,12 +246,13 @@ class Pickler extends Phase {
       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(adjustPrinter(rootCtx.fresh.setCompilationUnit(freshUnit), unit.typedAsJava)):
-        testSame(i"$unpickled%\n%", beforePickling(cls), cls)
+      else
+        val unpickled = unpickler.rootTrees
+        val freshUnit = CompilationUnit(rootCtx.compilationUnit.source)
+        freshUnit.needsCaptureChecking = unit.needsCaptureChecking
+        freshUnit.knowsPureFuns = unit.knowsPureFuns
+        inContext(rootCtx.fresh.setCompilationUnit(freshUnit)):
+          testSame(i"$unpickled%\n%", beforePickling(cls), cls)
 
   private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(using Context) =
     import java.nio.charset.StandardCharsets.UTF_8

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -81,8 +81,9 @@ Standard-Section: "ASTs" TopLevelStat*
   Param         = TypeParam
                   TermParam
   Template      = TEMPLATE       Length TypeParam* TermParam* parent_Term* Self?
-                                        Stat*                                      -- [typeparams] paramss extends parents { self => stats }, where Stat* always starts with the primary constructor.
+                                        EndParents? Stat*                          -- [typeparams] paramss extends parents { self => stats }, where Stat* always starts with the primary constructor.
   Self          = SELFDEF               selfName_NameRef selfType_Term             -- selfName : selfType
+  EndParents    = SPLITCLAUSE                                                      -- explicitly end the template header, e.g. if there is no primary constructor
 
   Term          = Path                                                             -- Paths represent both types and terms
                   IDENT                 NameRef Type                               -- Used when term ident’s type is not a TermRef