Pass data reader aroung to avoid accidental capture

Author: liufengyun

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

@@ -62,8 +62,6 @@ class ClassfileParser(
   import ClassfileConstants._
   import ClassfileParser._
 
-  protected var in: DataReader = _
-
   protected val staticModule: Symbol = moduleRoot.sourceModule(using ictx)
 
   protected val instanceScope: MutableScope = newScope     // the scope of all instance definitions
@@ -84,7 +82,7 @@ class ClassfileParser(
     throw new IOException(s"class file '${classfile.canonicalPath}' has location not matching its contents: contains class $className")
 
   def run()(using Context): Option[Embedded] = try ctx.base.reusableDataReader.using { reader =>
-    this.in = reader.reset(classfile)
+    implicit val in: DataReader = reader.reset(classfile)
 
     report.debuglog("[class] >> " + classRoot.fullName)
     parseHeader()
@@ -93,13 +91,13 @@ class ClassfileParser(
   }
   catch {
     case e: RuntimeException =>
-      if (ctx.debug) e.printStackTrace()
+      e.printStackTrace()
       throw new IOException(
         i"""class file ${classfile.canonicalPath} is broken, reading aborted with ${e.getClass}
            |${Option(e.getMessage).getOrElse("")}""")
   }
 
-  private def parseHeader(): Unit = {
+  private def parseHeader()(using in: DataReader): Unit = {
     val magic = in.nextInt
     if (magic != JAVA_MAGIC)
       throw new IOException(s"class file '${classfile}' has wrong magic number 0x${toHexString(magic)}, should be 0x${toHexString(JAVA_MAGIC)}")
@@ -120,7 +118,7 @@ class ClassfileParser(
 
   var sawPrivateConstructor: Boolean = false
 
-  def parseClass()(using Context): Option[Embedded] = {
+  def parseClass()(using ctx: Context, in: DataReader): Option[Embedded] = {
     val jflags       = in.nextChar
     val isAnnotation = hasAnnotation(jflags)
     val sflags       = classTranslation.flags(jflags)
@@ -220,7 +218,7 @@ class ClassfileParser(
     }
   }
 
-  def parseMember(method: Boolean)(using Context): Unit = {
+  def parseMember(method: Boolean)(using ctx: Context, in: DataReader): Unit = {
     val start = indexCoord(in.bp)
     val jflags = in.nextChar
     val sflags =
@@ -241,70 +239,67 @@ class ClassfileParser(
   val memberCompleter: LazyType = new LazyType {
 
     def complete(denot: SymDenotation)(using Context): Unit = ctx.base.reusableDataReader.using { reader =>
-      val oldIn = in
-      in = reader.reset(classfile)
-      try {
-        in.bp = denot.symbol.coord.toIndex
-        val sym = denot.symbol
-        val jflags = in.nextChar
-        val isEnum = (jflags & JAVA_ACC_ENUM) != 0
-        val name = pool.getName(in.nextChar)
-        val isConstructor = name eq nme.CONSTRUCTOR
-
-        /** Strip leading outer param from constructor and trailing access tag for
-         *  private inner constructors.
-         */
-        def normalizeConstructorParams() = innerClasses.get(currentClassName) match {
-          case Some(entry) if !isStatic(entry.jflags) =>
-            val mt @ MethodTpe(paramNames, paramTypes, resultType) = denot.info
-            var normalizedParamNames = paramNames.tail
-            var normalizedParamTypes = paramTypes.tail
-            if ((jflags & JAVA_ACC_SYNTHETIC) != 0) {
-              // SI-7455 strip trailing dummy argument ("access constructor tag") from synthetic constructors which
-              // are added when an inner class needs to access a private constructor.
-              normalizedParamNames = paramNames.dropRight(1)
-              normalizedParamTypes = paramTypes.dropRight(1)
-            }
-            denot.info = mt.derivedLambdaType(normalizedParamNames, normalizedParamTypes, resultType)
-          case _ =>
-        }
+      implicit val in: DataReader = reader.reset(classfile)
 
-        /** Make return type of constructor be the enclosing class type,
-         *  and make constructor type polymorphic in the type parameters of the class
-         */
-        def normalizeConstructorInfo() = {
-          val rt = classRoot.typeRef appliedTo (classRoot.typeParams map (_.typeRef))
-
-          def resultType(tpe: Type): Type = tpe match {
-            case mt @ MethodType(paramNames) => mt.derivedLambdaType(paramNames, mt.paramInfos, rt)
-            case pt : PolyType => pt.derivedLambdaType(pt.paramNames, pt.paramInfos, resultType(pt.resType))
+      in.bp = denot.symbol.coord.toIndex
+      val sym = denot.symbol
+      val jflags = in.nextChar
+      val isEnum = (jflags & JAVA_ACC_ENUM) != 0
+      val name = pool.getName(in.nextChar)
+      val isConstructor = name eq nme.CONSTRUCTOR
+
+      /** Strip leading outer param from constructor and trailing access tag for
+        *  private inner constructors.
+        */
+      def normalizeConstructorParams() = innerClasses.get(currentClassName) match {
+        case Some(entry) if !isStatic(entry.jflags) =>
+          val mt @ MethodTpe(paramNames, paramTypes, resultType) = denot.info
+          var normalizedParamNames = paramNames.tail
+          var normalizedParamTypes = paramTypes.tail
+          if ((jflags & JAVA_ACC_SYNTHETIC) != 0) {
+            // SI-7455 strip trailing dummy argument ("access constructor tag") from synthetic constructors which
+            // are added when an inner class needs to access a private constructor.
+            normalizedParamNames = paramNames.dropRight(1)
+            normalizedParamTypes = paramTypes.dropRight(1)
           }
+          denot.info = mt.derivedLambdaType(normalizedParamNames, normalizedParamTypes, resultType)
+        case _ =>
+      }
 
-          denot.info = resultType(denot.info)
-          addConstructorTypeParams(denot)
+      /** Make return type of constructor be the enclosing class type,
+        *  and make constructor type polymorphic in the type parameters of the class
+        */
+      def normalizeConstructorInfo() = {
+        val rt = classRoot.typeRef appliedTo (classRoot.typeParams map (_.typeRef))
+
+        def resultType(tpe: Type): Type = tpe match {
+          case mt @ MethodType(paramNames) => mt.derivedLambdaType(paramNames, mt.paramInfos, rt)
+          case pt : PolyType => pt.derivedLambdaType(pt.paramNames, pt.paramInfos, resultType(pt.resType))
         }
 
-        val isVarargs = denot.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
-        denot.info = pool.getType(in.nextChar, isVarargs)
-        if (isConstructor) normalizeConstructorParams()
-        denot.info = translateTempPoly(parseAttributes(sym, denot.info, isVarargs))
-        if (isConstructor) normalizeConstructorInfo()
+        denot.info = resultType(denot.info)
+        addConstructorTypeParams(denot)
+      }
 
-        if (ctx.explicitNulls) denot.info = JavaNullInterop.nullifyMember(denot.symbol, denot.info, isEnum)
+      val isVarargs = denot.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
+      denot.info = pool.getType(in.nextChar, isVarargs)
+      if (isConstructor) normalizeConstructorParams()
+      denot.info = translateTempPoly(parseAttributes(sym, denot.info, isVarargs))
+      if (isConstructor) normalizeConstructorInfo()
 
-        // seal java enums
-        if (isEnum) {
-          val enumClass = sym.owner.linkedClass
-          if (!enumClass.exists)
-            report.warning(s"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
-          else {
-            if (!enumClass.is(Flags.Sealed)) enumClass.setFlag(Flags.AbstractSealed)
-            enumClass.addAnnotation(Annotation.Child(sym, NoSpan))
-          }
+      if (ctx.explicitNulls) denot.info = JavaNullInterop.nullifyMember(denot.symbol, denot.info, isEnum)
+
+      // seal java enums
+      if (isEnum) {
+        val enumClass = sym.owner.linkedClass
+        if (!enumClass.exists)
+          report.warning(s"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
+        else {
+          if (!enumClass.is(Flags.Sealed)) enumClass.setFlag(Flags.AbstractSealed)
+          enumClass.addAnnotation(Annotation.Child(sym, NoSpan))
         }
       }
-      finally
-        in = oldIn
+
     }
   }
 
@@ -504,7 +499,7 @@ class ClassfileParser(
   }
   // sigToType
 
-  def parseAnnotArg(skip: Boolean = false)(using Context): Option[untpd.Tree] = {
+  def parseAnnotArg(skip: Boolean = false)(using ctx: Context, in: DataReader): Option[untpd.Tree] = {
 
     // 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
@@ -569,7 +564,7 @@ class ClassfileParser(
   /** Parse and return a single annotation.  If it is malformed,
    *  return None.
    */
-  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(using Context): Option[ClassfileAnnotation] = try {
+  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(using ctx: Context, in: DataReader): Option[ClassfileAnnotation] = try {
     val attrType = pool.getType(attrNameIndex)
     attrType match
       case tp: TypeRef =>
@@ -608,7 +603,7 @@ class ClassfileParser(
       None // ignore malformed annotations
   }
 
-  def parseAttributes(sym: Symbol, symtype: Type, isVarargs: Boolean = false)(using Context): Type = {
+  def parseAttributes(sym: Symbol, symtype: Type, isVarargs: Boolean = false)(using ctx: Context, in: DataReader): Type = {
     var newType = symtype
 
     def parseAttribute(): Unit = {
@@ -749,7 +744,7 @@ class ClassfileParser(
    *  Restores the old `bp`.
    *  @return true iff classfile is from Scala, so no Java info needs to be read.
    */
-  def unpickleOrParseInnerClasses()(using Context): Option[Embedded] = {
+  def unpickleOrParseInnerClasses()(using ctx: Context, in: DataReader): Option[Embedded] = {
     val oldbp = in.bp
     try {
       skipSuperclasses()
@@ -985,21 +980,21 @@ class ClassfileParser(
     }
   }
 
-  def skipAttributes(): Unit = {
+  def skipAttributes()(using in: DataReader): Unit = {
     val attrCount = in.nextChar
     for (i <- 0 until attrCount) {
       in.skip(2); in.skip(in.nextInt)
     }
   }
 
-  def skipMembers(): Unit = {
+  def skipMembers()(using in: DataReader): Unit = {
     val memberCount = in.nextChar
     for (i <- 0 until memberCount) {
       in.skip(6); skipAttributes()
     }
   }
 
-  def skipSuperclasses(): Unit = {
+  def skipSuperclasses()(using in: DataReader): Unit = {
     in.skip(2) // superclass
     val ifaces = in.nextChar
     in.skip(2 * ifaces)
@@ -1035,7 +1030,7 @@ class ClassfileParser(
       requiredModule(name.dropRight(1))
     else classNameToSymbol(name)
 
-  class ConstantPool {
+  class ConstantPool(using in: DataReader) {
     private val len = in.nextChar
     private val starts = new Array[Int](len)
     private val values = new Array[AnyRef](len)