Fix FromTasty not loading modules

Author: nicolasstucki

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

@@ -12,12 +12,12 @@ import SymDenotations._
 import typer.FrontEnd
 import Phases.Phase
 import util._
-import reporting.Reporter
 import Decorators._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.NameOps._
 import dotty.tools.dotc.transform.Pickler
-import tasty.DottyUnpickler
-import ast.tpd._
-import NameKinds.QualifiedName
 
 /** Compiler for TASTY files.
  *  Usage:
@@ -65,36 +65,44 @@ object FromTasty extends Driver {
     override def isTyper = false
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
-      units.map(readTASTY)
+      units.flatMap(readTASTY)
 
-    def readTASTY(unit: CompilationUnit)(implicit ctx: Context): CompilationUnit = unit match {
+    def readTASTY(unit: CompilationUnit)(implicit ctx: Context): List[CompilationUnit] = unit match {
       case unit: TASTYCompilationUnit =>
         assert(ctx.settings.YretainTrees.value)
         val className = unit.className.toTypeName
-        ctx.base.staticRef(className) match {
-          case clsd: ClassDenotation =>
-            def cannotUnpickle(reason: String) =
-              ctx.error(s"class $className cannot be unpickled because $reason")
-            def tryToLoad = clsd.infoOrCompleter match {
-              case info: ClassfileLoader =>
-                info.load(clsd)
-                Option(clsd.symbol.asClass.tree).orElse {
-                  cannotUnpickle(s"its class file ${info.classfile} does not have a TASTY attribute")
-                  None
-                }
+        val compilationUnits = List(tree(className), tree(className.moduleClassName)).flatMap {
+          case Some((clsd, unpickled)) if !unpickled.isEmpty =>
+            List(CompilationUnit.mkCompilationUnit(clsd, unpickled, forceTrees = true))
+          case _ => Nil
+        }
+        compilationUnits
+    }
 
-              case info =>
-                cannotUnpickle(s"its info of type ${info.getClass} is not a ClassfileLoader")
+    private def tree(className: TypeName)(implicit ctx: Context): Option[(ClassDenotation, tpd.Tree)] = {
+      val clsd = ctx.base.staticRef(className)
+      ctx.base.staticRef(className) match {
+        case clsd: ClassDenotation =>
+          def cannotUnpickle(reason: String) =
+            ctx.error(s"class $className cannot be unpickled because $reason")
+          def tryToLoad = clsd.infoOrCompleter match {
+            case info: ClassfileLoader =>
+              info.load(clsd)
+              Option(clsd.symbol.asClass.tree).orElse {
+                cannotUnpickle(s"its class file ${info.classfile} does not have a TASTY attribute")
                 None
-            }
-            Option(clsd.symbol.asClass.tree).orElse(tryToLoad)
-              .map(unpickled => CompilationUnit.mkCompilationUnit(clsd, unpickled, forceTrees = true))
-              .getOrElse(unit)
+              }
 
-          case _ =>
-            ctx.error(s"class not found: $className")
-            unit
-        }
+            case info =>
+              cannotUnpickle(s"its info of type ${info.getClass} is not a ClassfileLoader")
+              None
+          }
+          Option(clsd.symbol.asClass.tree).orElse(tryToLoad).map(tree => (clsd, tree))
+
+        case _ =>
+          ctx.error(s"class not found: $className")
+          None
+      }
     }
   }
 }

compiler/test/dotty/tools/dotc/FromTastyTests.scala

@@ -36,7 +36,8 @@ class FromTastyTests extends ParallelTesting {
     implicit val testGroup: TestGroup = TestGroup("runTestFromTasty")
     val (step1, step2) = {
       // compileTastyInDir("../tests/run", defaultOptions) + // FIXME
-      compileTastyInDir("../tests/run-from-tasty", defaultOptions)
+      compileTastyInDir("../tests/run-from-tasty", defaultOptions) +
+      compileTasty("../tests/run/t493.scala", defaultOptions)
     }
     step1.keepOutput.checkCompile() // Compile all files to generate the class files with tasty
     step2.keepOutput.checkRuns() // Compile from tasty and run the result

tests/run-from-tasty/innerClass.scala

@@ -6,7 +6,6 @@ package foo {
 
 }
 
-class Test
 object Test {
   def main(args: Array[String]): Unit = {
     val a = new foo.A

tests/run-from-tasty/simpleClass.scala

@@ -6,7 +6,6 @@ package foo {
 
 }
 
-class Test
 object Test {
   def main(args: Array[String]): Unit = {
     println(new foo.A().getClass.getName)