Refactor constant parsing

It is better to handle the conversion in the context
where conversion is expected.

Author: liufengyun

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

@@ -235,9 +235,8 @@ class ClassfileParser(
         getOwner(jflags), preName.name, sflags, completer,
         getPrivateWithin(jflags), coord = start)
 
-      val pt = if sig.size == 1 then constantTagToType(sig(0)) else WildcardType
       val isVarargs = sflags.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
-      completer.attrCompleter = parseAttributes(member, pt, isVarargs)
+      completer.attrCompleter = parseAttributes(member, isVarargs)
 
       getScope(jflags).enter(member)
 
@@ -324,6 +323,21 @@ class ClassfileParser(
       case BOOL_TAG   => defn.BooleanType
     }
 
+  /** As specified in https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.16.1,
+   *  an annotation argument of type boolean, byte, char or short will
+   *  be represented as a CONSTANT_INTEGER, so we need to convert it to
+   *  produce a correctly-typed tree. We need to do this each time the
+   *  constant is accessed instead of storing the result of the
+   *  conversion in the `values` cache, because the same constant might
+   *  be used for annotation arguments of different type.
+   */
+  def convertTo(ct: Constant, pt: Type)(using Context): Constant = {
+    if (pt eq defn.BooleanType) && ct.tag == IntTag then
+      Constant(ct.value != 0)
+    else
+      ct.convertTo(pt)
+  }
+
   private def sigToType(sig: String, owner: Symbol = null, isVarargs: Boolean = false)(using Context): Type = {
     var index = 0
     val end = sig.length
@@ -525,7 +539,10 @@ class ClassfileParser(
       case STRING_TAG =>
         if (skip) None else Some(lit(Constant(pool.getName(index).value)))
       case BOOL_TAG | BYTE_TAG | CHAR_TAG | SHORT_TAG =>
-        if (skip) None else Some(lit(pool.getConstant(index, constantTagToType(tag))))
+        if (skip) None else {
+          val constant = convertTo(pool.getConstant(index), constantTagToType(tag))
+          Some(lit(constant))
+        }
       case INT_TAG | LONG_TAG | FLOAT_TAG | DOUBLE_TAG =>
         if (skip) None else Some(lit(pool.getConstant(index)))
       case CLASS_TAG =>
@@ -612,17 +629,27 @@ class ClassfileParser(
   }
 
   abstract class AttributeCompleter {
+    var constant: Constant = null
     var exceptions: List[NameOrString] = Nil
     def complete(tp: Type)(using Context): Type
   }
 
   // invariant: `in` and `ctx` should not be captured inside the result function
-  def parseAttributes(sym: Symbol, pt: Type = WildcardType, isVarargs: Boolean = false)(using ctx: Context, in: DataReader): AttributeCompleter = {
+  def parseAttributes(sym: Symbol, isVarargs: Boolean = false)(using ctx: Context, in: DataReader): AttributeCompleter = {
     var typeUpdate: Option[Context ?=> Type] = None
     var delayedWork: List[Context ?=> Unit] = Nil
     val res = new AttributeCompleter {
       def complete(tp: Type)(using Context): Type = {
-        val newType = if (typeUpdate.isEmpty) tp else typeUpdate.get
+        val updatedType =
+          if typeUpdate.isEmpty then tp
+          else typeUpdate.get
+
+        val newType =
+          if this.constant != null then
+            val ct = convertTo(this.constant, updatedType)
+            if ct != null then ConstantType(ct) else updatedType
+          else updatedType
+
         exceptions.foreach { ex =>
           val cls = getClassSymbol(ex.name)
           sym.addAnnotation(ThrowsAnnotation(cls.asClass))
@@ -658,8 +685,8 @@ class ClassfileParser(
           sym.addAnnotation(Annotation(defn.DeprecatedAnnot, msg, since))
 
         case tpnme.ConstantValueATTR =>
-          val c = pool.getConstant(in.nextChar, pt)
-          if (c ne null) typeUpdate = Some { ConstantType(c) }
+          val c = pool.getConstant(in.nextChar)
+          if (c ne null) res.constant = c
           else report.warning(s"Invalid constant in attribute of ${sym.showLocated} while parsing ${classfile}")
 
         case tpnme.AnnotationDefaultATTR =>
@@ -1183,7 +1210,7 @@ class ClassfileParser(
       getClassSymbol(index)
     }
 
-    def getConstant(index: Int, pt: Type = WildcardType)(using ctx: Context, in: DataReader): Constant = {
+    def getConstant(index: Int)(using ctx: Context, in: DataReader): Constant = {
       if (index <= 0 || len <= index) errorBadIndex(index)
       var value = values(index)
       if (value eq null) {
@@ -1207,21 +1234,7 @@ class ClassfileParser(
         values(index) = value
       }
       value match {
-        case ct: Constant =>
-          if pt ne WildcardType then
-            // As specified in https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.16.1,
-            // an annotation argument of type boolean, byte, char or short will
-            // be represented as a CONSTANT_INTEGER, so we need to convert it to
-            // produce a correctly-typed tree. We need to do this each time the
-            // constant is accessed instead of storing the result of the
-            // conversion in the `values` cache, because the same constant might
-            // be used for annotation arguments of different type.
-            if (pt eq defn.BooleanType) && ct.tag == IntTag then
-              Constant(ct.value != 0)
-            else
-              ct.convertTo(pt)
-          else
-            ct
+        case ct: Constant  => ct
         case cls: Symbol   => Constant(cls.typeRef)
         case arr: Type     => Constant(arr)
       }