Use JarWriter only when target jar is empty

Author: WojciechMazur

Diff for: compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -22,9 +22,8 @@ class GenBCode extends Phase { self =>
     superCallsMap.update(sym, old + calls)
   }
 
-  private[jvm] val entryPoints = new mutable.HashSet[String]()
-  def registerEntryPoint(s: String): Unit =
-    entryPoints += s
+  private val entryPoints = new mutable.HashSet[String]()
+  def registerEntryPoint(s: String): Unit = entryPoints += s
 
   private var _backendInterface: DottyBackendInterface = _
   def backendInterface(using ctx: Context): DottyBackendInterface = {
@@ -56,7 +55,7 @@ class GenBCode extends Phase { self =>
   private var _frontendAccess: PostProcessorFrontendAccess = _
   def frontendAccess(using Context): PostProcessorFrontendAccess = {
     if _frontendAccess eq null then
-      _frontendAccess = PostProcessorFrontendAccess.Impl(backendInterface)
+      _frontendAccess = PostProcessorFrontendAccess.Impl(backendInterface, entryPoints)
     _frontendAccess
   }
 

Diff for: compiler/src/dotty/tools/backend/jvm/PostProcessor.scala

@@ -18,7 +18,7 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, val bTypes:
   import int.given
 
   val backendUtils = new BackendUtils(this)
-  lazy val classfileWriter  = ClassfileWriter(frontendAccess)
+  val classfileWriter  = ClassfileWriter(frontendAccess)
 
   def postProcessAndSendToDisk(generatedDefs: GeneratedDefs): Unit = {
     val GeneratedDefs(classes, tasty) = generatedDefs
@@ -30,21 +30,18 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, val bTypes:
           serializeClass(classNode)
         catch
           case e: java.lang.RuntimeException if e.getMessage != null && e.getMessage.nn.contains("too large!") =>
-            backendReporting.error(
-              s"Could not write class ${classNode.name} because it exceeds JVM code size limits. ${e.getMessage}",
-              NoSourcePosition
-            )
+            backendReporting.error(s"Could not write class ${classNode.name} because it exceeds JVM code size limits. ${e.getMessage}")
             null
           case ex: Throwable =>
             ex.printStackTrace()
-            backendReporting.error(s"Error while emitting ${classNode.name}\n${ex.getMessage}",NoSourcePosition)
+            backendReporting.error(s"Error while emitting ${classNode.name}\n${ex.getMessage}")
             null
 
       if (bytes != null) {
         if (AsmUtils.traceSerializedClassEnabled && classNode.name.nn.contains(AsmUtils.traceSerializedClassPattern))
           AsmUtils.traceClass(bytes)
 
-        val clsFile = classfileWriter.write(classNode.name.nn, bytes, sourceFile)
+        val clsFile = classfileWriter.writeClass(classNode.name.nn, bytes, sourceFile)
         if clsFile != null then onFileCreated(clsFile)
       }
     }

Diff for: compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala

@@ -1,6 +1,6 @@
 package dotty.tools.backend.jvm
 
-import scala.collection.mutable.Clearable
+import scala.collection.mutable.{Clearable, HashSet}
 import dotty.tools.dotc.util.*
 import dotty.tools.io.AbstractFile
 import java.util.{Collection => JCollection, Map => JMap}
@@ -20,7 +20,7 @@ sealed abstract class PostProcessorFrontendAccess {
   def getEntryPoints: List[String]
 
   private val frontendLock: AnyRef = new Object()
-  @inline final def frontendSynch[T](x: => T): T = frontendLock.synchronized(x)
+  inline final def frontendSynch[T](inline x: => T): T = frontendLock.synchronized(x)
 }
 
 object PostProcessorFrontendAccess {
@@ -35,11 +35,12 @@ object PostProcessorFrontendAccess {
   }
 
   sealed trait BackendReporting {
-    def error(message: String, pos: SourcePosition): Unit
+    def error(message: String): Unit
+    def warning(message: String): Unit
     def log(message: String): Unit
   }
 
-  class Impl[I <: DottyBackendInterface](val int: I) extends PostProcessorFrontendAccess {
+  class Impl[I <: DottyBackendInterface](val int: I, entryPoints: HashSet[String]) extends PostProcessorFrontendAccess {
     import int.given
     lazy val compilerSettings: CompilerSettings = buildCompilerSettings()
 
@@ -67,13 +68,11 @@ object PostProcessorFrontendAccess {
      }
 
     object backendReporting extends BackendReporting {
-      def error(message: String, pos: SourcePosition): Unit = frontendSynch(report.error(message, pos))
+      def error(message: String): Unit = frontendSynch(report.error(message, NoSourcePosition))
+      def warning(message: String): Unit = frontendSynch(report.warning(message, NoSourcePosition))
       def log(message: String): Unit = frontendSynch(report.log(message))
     }
 
-    def getEntryPoints: List[String] = frontendSynch(Phases.genBCodePhase match {
-      case genBCode: GenBCode => genBCode.entryPoints.toList
-      case _ => Nil
-    })
+    def getEntryPoints: List[String] = frontendSynch(entryPoints.toList)
   }
 }