Specialize more to avoid closure creation

Author: liufengyun

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

@@ -235,8 +235,7 @@ class ClassfileParser(
         getOwner(jflags), preName.name, sflags, completer,
         getPrivateWithin(jflags), coord = start)
 
-      val isVarargs = sflags.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
-      completer.attrCompleter = parseAttributes(member, isVarargs)
+      completer.attrCompleter = parseAttributes(member)
 
       getScope(jflags).enter(member)
 
@@ -291,7 +290,7 @@ class ClassfileParser(
       val isVarargs = denot.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
       denot.info = sigToType(sig, isVarargs = isVarargs)
       if (isConstructor) normalizeConstructorParams()
-      denot.info = translateTempPoly(attrCompleter.complete(denot.info))
+      denot.info = translateTempPoly(attrCompleter.complete(denot.info, isVarargs))
       if (isConstructor) normalizeConstructorInfo()
 
       if (ctx.explicitNulls) denot.info = JavaNullInterop.nullifyMember(denot.symbol, denot.info, isEnum)
@@ -628,36 +627,49 @@ class ClassfileParser(
       None // ignore malformed annotations
   }
 
-  abstract class AttributeCompleter {
+  class AttributeCompleter(sym: Symbol) {
+    var codeAttribute: Boolean = false
+    var sig: String = null
     var constant: Constant = null
     var exceptions: List[NameOrString] = Nil
-    def complete(tp: Type)(using Context): Type
-  }
+    var annotations: List[Annotation] = Nil
+    def complete(tp: Type, isVarargs: Boolean = false)(using Context): Type = {
+        // flag test will trigger completion and cycles, thus have to be lazy
+      if (codeAttribute && sym.owner.isAllOf(Flags.JavaInterface)) {
+        sym.resetFlag(Flags.Deferred)
+        sym.owner.resetFlag(Flags.PureInterface)
+        report.log(s"$sym in ${sym.owner} is a java 8+ default method.")
+      }
 
-  // invariant: `in` and `ctx` should not be captured inside the result function
-  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 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))
+      val updatedType =
+        if sig == null then tp
+        else {
+          val newType = sigToType(sig, sym, isVarargs)
+          if (ctx.debug && ctx.verbose)
+            println("" + sym + "; signature = " + sig + " type = " + newType)
+          newType
         }
-        delayedWork.foreach(_.apply)
-        cook.apply(newType)
+
+      val newType =
+        if this.constant != null then
+          val ct = convertTo(this.constant, updatedType)
+          if ct != null then ConstantType(ct) else updatedType
+        else updatedType
+
+      annotations.foreach(annot => sym.addAnnotation(annot))
+
+      exceptions.foreach { ex =>
+        val cls = getClassSymbol(ex.name)
+        sym.addAnnotation(ThrowsAnnotation(cls.asClass))
       }
+
+      cook.apply(newType)
     }
+  }
+
+  // invariant: `in` and `ctx` should not be captured inside the result function
+  def parseAttributes(sym: Symbol)(using ctx: Context, in: DataReader): AttributeCompleter = {
+    val res = new AttributeCompleter(sym)
 
     def parseAttribute(): Unit = {
       val attrName = pool.getName(in.nextChar).name.toTypeName
@@ -666,12 +678,7 @@ class ClassfileParser(
       attrName match {
         case tpnme.SignatureATTR =>
           val sig = pool.getExternalName(in.nextChar)
-          typeUpdate = Some {
-            val newType = sigToType(sig.value, sym, isVarargs)
-            if (ctx.debug && ctx.verbose)
-              println("" + sym + "; signature = " + sig + " type = " + newType)
-            newType
-          }
+          res.sig = sig.value
 
         case tpnme.SyntheticATTR =>
           sym.setFlag(Flags.SyntheticArtifact)
@@ -682,7 +689,7 @@ class ClassfileParser(
         case tpnme.DeprecatedATTR =>
           val msg = Literal(Constant("see corresponding Javadoc for more information."))
           val since = Literal(Constant(""))
-          delayedWork ::= sym.addAnnotation(Annotation(defn.DeprecatedAnnot, msg, since))
+          res.annotations ::= Annotation(defn.DeprecatedAnnot, msg, since)
 
         case tpnme.ConstantValueATTR =>
           val c = pool.getConstant(in.nextChar)
@@ -708,14 +715,7 @@ class ClassfileParser(
 
         case tpnme.CodeATTR =>
           in.skip(attrLen)
-          // flag test will trigger completion and cycles, thus have to be lazy
-          delayedWork ::= {
-            if (sym.owner.isAllOf(Flags.JavaInterface)) {
-              sym.resetFlag(Flags.Deferred)
-              sym.owner.resetFlag(Flags.PureInterface)
-              report.log(s"$sym in ${sym.owner} is a java 8+ default method.")
-            }
-          }
+          res.codeAttribute = true
 
         case _ =>
       }