Fix #10131: load enum types more lazily

Author: liufengyun

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

@@ -518,7 +518,14 @@ class ClassfileParser(
   }
   // sigToType
 
-  def parseAnnotArg(skip: Boolean = false)(using ctx: Context, in: DataReader): Option[untpd.Tree] = {
+  type EnumTag = (String, NameOrString)
+  def enumTagTree(tag: EnumTag)(using Context): untpd.Tree = {
+    val enumClassTp = sigToType(tag._1)
+    val enumModuleClass = enumClassTp.classSymbol.companionModule
+    Select(ref(enumModuleClass), tag._2.name)
+  }
+
+  def parseAnnotArg(skip: Boolean = false)(using ctx: Context, in: DataReader): Option[untpd.Tree | EnumTag] = {
 
     // If we encounter an empty array literal, we need the type of the corresponding
     // parameter to properly type it, but that would require forcing the annotation
@@ -545,20 +552,16 @@ class ClassfileParser(
       case CLASS_TAG =>
         if (skip) None else Some(lit(Constant(pool.getType(index))))
       case ENUM_TAG =>
-        val enumClassTp = pool.getType(index)
+        val sig = pool.getExternalName(index).value
         val enumCaseName = pool.getName(in.nextChar)
-        if (skip)
-          None
-        else {
-          val enumModuleClass = enumClassTp.classSymbol.companionModule
-          Some(Select(ref(enumModuleClass), enumCaseName.name))
-        }
+        if (skip) None else Some(sig -> enumCaseName)
       case ARRAY_TAG =>
         val arr = new ArrayBuffer[Tree]()
         var hasError = false
         for (i <- 0 until index)
           parseAnnotArg(skip) match {
-            case Some(c) => arr += c
+            case Some(c: untpd.Tree) => arr += c
+            case Some(tag: EnumTag) => arr += enumTagTree(tag)
             case None => hasError = true
           }
         if (hasError) None
@@ -572,7 +575,13 @@ class ClassfileParser(
     }
   }
 
-  class ClassfileAnnotation(annotType: Type, args: List[untpd.Tree]) extends LazyAnnotation {
+  class ClassfileAnnotation(annotType: Type, lazyArgs: List[untpd.Tree | (Context => untpd.Tree)]) extends LazyAnnotation {
+    val args: Context ?=> List[untpd.Tree] = (using ctx: Context) =>
+      lazyArgs.map {
+        case tree: untpd.Tree                         => tree
+        case fun: (Context => untpd.Tree) @unchecked  => fun(ctx)
+      }
+
     protected var mySym: Symbol | (Context ?=> Symbol) =
       (using ctx: Context) => annotType.classSymbol
 
@@ -598,13 +607,19 @@ class ClassfileParser(
       case _ =>
 
     val nargs = in.nextChar
-    val argbuf = new ListBuffer[untpd.Tree]
+    val argbuf = new ListBuffer[untpd.Tree | (Context => untpd.Tree)]
     var hasError = false
     for (i <- 0 until nargs) {
       val name = pool.getName(in.nextChar)
       parseAnnotArg(skip) match {
-        case Some(arg) => argbuf += untpd.NamedArg(name.name, arg)
-        case None => hasError = !skip
+        case Some(tag: EnumTag) =>
+          argbuf += ((ctx: Context) => untpd.NamedArg(name.name, enumTagTree(tag)(using ctx)))
+
+        case Some(arg: untpd.Tree) =>
+          argbuf += untpd.NamedArg(name.name, arg)
+
+        case None =>
+          hasError = !skip
       }
     }
     if (hasError || skip) None