Post-rebase fixes

Author: jchyb

compiler/src/dotty/tools/dotc/Run.scala

@@ -225,18 +225,15 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       if (ctx.settings.YtestPickler.value) List("pickler")
       else ctx.settings.YstopAfter.value
 
-    var forceReachPhaseMaybe =
-      if (ctx.isBestEffort) Some("typer")
-      else None
-
-    var reachedSemanticDB = false
-    var reachedPickler = false
-
     val pluginPlan = ctx.base.addPluginPhases(ctx.base.phasePlan)
     val phases = ctx.base.fusePhases(pluginPlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.base.usePhases(phases)
 
+    var forceReachPhaseMaybe =
+      if (ctx.isBestEffort && phases.exists(_.phaseName == "typer")) Some("typer")
+      else None
+
     if ctx.settings.YnoDoubleBindings.value then
       ctx.base.checkNoDoubleBindings = true
 
@@ -263,17 +260,6 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
               case _ =>
             }
 
-            if phase.phaseName == "extractSemanticDB" then reachedSemanticDB = true
-            if phase.phaseName == "pickler" then reachedPickler = true
-
-            if !reachedSemanticDB && forceReachPhaseMaybe.isEmpty && ctx.reporter.hasErrors && ctx.isBestEffort then
-              ctx.base.allPhases.find(_.phaseName == "extractSemanticDB").foreach(_.runOn(units))
-              reachedSemanticDB = true
-
-            if !reachedPickler && forceReachPhaseMaybe.isEmpty && ctx.reporter.hasErrors && ctx.isBestEffort then
-              ctx.base.allPhases.find(_.phaseName == "pickler").foreach(_.runOn(units))
-              reachedPickler = true
-
             report.informTime(s"$phase ", start)
             Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
             for (unit <- units)

compiler/src/dotty/tools/dotc/classpath/FileUtils.scala

@@ -24,8 +24,12 @@ object FileUtils {
 
     def hasTastyExtension: Boolean = file.hasExtension("tasty")
 
+    def hasBetastyExtension: Boolean = file.hasExtension("betasty")
+
     def isTasty: Boolean = !file.isDirectory && hasTastyExtension
 
+    def isBestEffortTasty: Boolean = !file.isDirectory && hasBetastyExtension
+
     def isScalaBinary: Boolean = file.isClass || file.isTasty
 
     def isScalaOrJavaSource: Boolean = !file.isDirectory && (file.hasExtension("scala") || file.hasExtension("java"))

compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -7,14 +7,14 @@ import java.nio.channels.ClosedByInterruptException
 
 import scala.util.control.NonFatal
 
-import dotty.tools.dotc.classpath.FileUtils.isTasty
+import dotty.tools.dotc.classpath.FileUtils.{isTasty, isBestEffortTasty}
 import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
 import NameOps._
 import StdNames._
-import classfile.{ClassfileParser, ClassfileTastyUUIDParser, BestEffortTastyParser}
+import classfile.{ClassfileParser, ClassfileTastyUUIDParser}
 import Decorators._
 
 import util.Stats
@@ -198,7 +198,7 @@ object SymbolLoaders {
         enterToplevelsFromSource(owner, nameOf(classRep), src)
       case (Some(bin), _) =>
         val completer =
-          if bin.isTasty then ctx.platform.newTastyLoader(bin)
+          if bin.isTasty || bin.isBestEffortTasty then ctx.platform.newTastyLoader(bin)
           else ctx.platform.newClassLoader(bin)
         enterClassAndModule(owner, nameOf(classRep), completer)
     }
@@ -411,40 +411,38 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
 
   override def doComplete(root: SymDenotation)(using Context): Unit =
     val (classRoot, moduleRoot) = rootDenots(root.asClass)
-    val isBestEffortTasty = classfile.name.endsWith(".betasty")
-    val result =
-      if isBestEffortTasty then // TODO move to TastyLoader
-        new BestEffortTastyParser(classfile, classRoot, moduleRoot)(ctx).run()
-      else
-        new ClassfileParser(classfile, classRoot, moduleRoot)(ctx).run()
-
-    if (mayLoadTreesFromTasty || (isBestEffortTasty && ctx.withBestEffortTasty))
-      result match {
-        case Some(unpickler: tasty.DottyUnpickler) =>
-          classRoot.classSymbol.rootTreeOrProvider = unpickler
-          moduleRoot.classSymbol.rootTreeOrProvider = unpickler
-        case _ =>
-      }
+    val result = new ClassfileParser(classfile, classRoot, moduleRoot)(ctx).run()
+    result match {
+      case Some(unpickler: tasty.DottyUnpickler) =>
+        classRoot.classSymbol.rootTreeOrProvider = unpickler
+        moduleRoot.classSymbol.rootTreeOrProvider = unpickler
+      case _ =>
+    }
 
-  private def mayLoadTreesFromTasty(using Context): Boolean =
-    ctx.settings.YretainTrees.value || ctx.settings.fromTasty.value
 }
 
 class TastyLoader(val tastyFile: AbstractFile) extends SymbolLoader {
 
   override def sourceFileOrNull: AbstractFile | Null = tastyFile
 
-  def description(using Context): String = "TASTy file " + tastyFile.toString
+  def description(using Context): String =
+    if tastyFile.extension == ".betasty" then "Best Effort TASTy file " + tastyFile.toString
+    else "TASTy file " + tastyFile.toString
 
   override def doComplete(root: SymDenotation)(using Context): Unit =
     val (classRoot, moduleRoot) = rootDenots(root.asClass)
+    val isBestEffortTasty = tastyFile.name.endsWith(".betasty")
     val tastyBytes = tastyFile.toByteArray
-    val unpickler = new tasty.DottyUnpickler(tastyBytes)
+    val unpickler = new tasty.DottyUnpickler(tastyBytes, withBestEffortTasty = ctx.withBestEffortTasty)
     unpickler.enter(roots = Set(classRoot, moduleRoot, moduleRoot.sourceModule))(using ctx.withSource(util.NoSource))
-    if mayLoadTreesFromTasty then
+    if mayLoadTreesFromTasty || (isBestEffortTasty && ctx.withBestEffortTasty) then
       classRoot.classSymbol.rootTreeOrProvider = unpickler
       moduleRoot.classSymbol.rootTreeOrProvider = unpickler
-    checkTastyUUID(tastyFile, tastyBytes)
+    if isBestEffortTasty then
+      checkBeTastyUUID(tastyFile, tastyBytes)
+      ctx.setUsesBestEffortTasty()
+    else
+      checkTastyUUID(tastyFile, tastyBytes)
 
 
   private def checkTastyUUID(tastyFile: AbstractFile, tastyBytes: Array[Byte])(using Context): Unit =
@@ -458,6 +456,9 @@ class TastyLoader(val tastyFile: AbstractFile) extends SymbolLoader {
       // This will be the case in any of our tests that compile with `-Youtput-only-tasty`
       report.inform(s"No classfiles found for $tastyFile when checking TASTy UUID")
 
+  private def checkBeTastyUUID(tastyFile: AbstractFile, tastyBytes: Array[Byte])(using Context): Unit =
+    new TastyHeaderUnpickler(tastyBytes).readHeader(true)
+
   private def mayLoadTreesFromTasty(using Context): Boolean =
     ctx.settings.YretainTrees.value || ctx.settings.fromTasty.value
 }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3052,7 +3052,8 @@ object Types {
       if (ctx.erasedTypes) tref
       else cls.info match {
         case cinfo: ClassInfo => cinfo.selfType
-        case _: ErrorType | NoType if ctx.mode.is(Mode.Interactive) => cls.info
+        case _: ErrorType | NoType
+          if ctx.mode.is(Mode.Interactive) || ctx.isBestEffort || ctx.usesBestEffortTasty => cls.info // TODO aggregate
           // can happen in IDE if `cls` is stale
       }
 

compiler/src/dotty/tools/dotc/core/classfile/BestEffortTastyParser.scala

@@ -41,7 +41,7 @@ class ExtractSemanticDB extends Phase:
   override def isRunnable(using Context) =
     import ExtractSemanticDB.{semanticdbTarget, outputDirectory}
     def writesToOutputJar = semanticdbTarget.isEmpty && outputDirectory.isInstanceOf[JarArchive]
-    super.isRunnable && ctx.settings.Xsemanticdb.value && !writesToOutputJar
+    (super.isRunnable || ctx.isBestEffort) && ctx.settings.Xsemanticdb.value && !writesToOutputJar
 
   // Check not needed since it does not transform trees
   override def isCheckable: Boolean = false

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -41,7 +41,7 @@ class Pickler extends Phase {
 
   // No need to repickle trees coming from TASTY
   override def isRunnable(using Context): Boolean =
-    super.isRunnable && !ctx.settings.fromTasty.value && (ctx.isBestEffort || !ctx.usesBestEffortTasty)
+    (super.isRunnable || ctx.isBestEffort) && !ctx.settings.fromTasty.value
 
   private def output(name: String, msg: String) = {
     val s = new PrintStream(name)

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

@@ -15,4 +15,10 @@ curried-dependent-ift.scala
 safeThrowsStrawman2.scala
 varargs-annot-2.scala
 i1642.scala
-i2202.scala
+i2202.scala
+
+# new errors TODO check
+type-test-paths.scala
+type-test-paths-2.scala
+erased-in-tuples.scala
+i15158.scala

compiler/test/dotc/neg-best-effort-pickling.blacklist

@@ -9,6 +9,6 @@ i0091-infpaths.scala
 exports.scala
 i14834.scala
 
-# unpickling crashes
+# other type related crashes
 i4653.scala
-#i16407.scala
+overrideClass.scala

compiler/test/dotc/neg-best-effort-unpickling.blacklist

@@ -8,6 +8,8 @@ import org.junit.{ Test, AfterClass }
 import reporting.TestReporter
 import java.io.{File => JFile}
 
+import scala.language.unsafeNulls
+
 class BestEffortCompilationTests {
   import ParallelTesting._
   import vulpix.TestConfiguration._