address review comments

- add check files for run/unroll tests
- refactorings
- test clause interleaving and value class

Author: bishabosha

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

@@ -59,8 +59,8 @@ class CompilationUnit protected (val source: SourceFile, val info: CompilationUn
 
   var hasMacroAnnotations: Boolean = false
 
-  def hasUnrollDefs: Boolean = unrolledClasses != null
-  var unrolledClasses: Set[Symbol] | Null = null
+  def hasUnrollDefs: Boolean = unrolledClasses.nonEmpty
+  var unrolledClasses: Set[Symbol] = Set.empty
 
   /** Set to `true` if inliner added anonymous mirrors that need to be completed */
   var needsMirrorSupport: Boolean = false

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -1072,7 +1072,9 @@ object Denotations {
     def filterDisjoint(denots: PreDenotation)(using Context): SingleDenotation =
       if (denots.exists && denots.matches(this)) NoDenotation else this
     def filterWithFlags(required: FlagSet, excluded: FlagSet)(using Context): SingleDenotation =
-      val realExcluded = if ctx.isAfterTyper then excluded else excluded | (if ctx.mode.is(Mode.ResolveFromTASTy) then EmptyFlags else Invisible)
+      val realExcluded =
+        if ctx.isAfterTyper || ctx.mode.is(Mode.ResolveFromTASTy) then excluded
+        else excluded | Invisible
       def symd: SymDenotation = this match
         case symd: SymDenotation => symd
         case _ => symbol.denot

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -20,7 +20,6 @@ import collection.mutable
 import reporting.{Profile, NoProfile}
 import dotty.tools.tasty.TastyFormat.ASTsSection
 import quoted.QuotePatterns
-import dotty.tools.dotc.config.Feature
 
 object TreePickler:
   class StackSizeExceeded(val mdef: tpd.MemberDef) extends Exception
@@ -475,16 +474,15 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
             case _ =>
               if passesConditionForErroringBestEffortCode(tree.hasType) then
                 // #19951 The signature of a constructor of a Java annotation is irrelevant
-                val sym = tree.symbol
                 val sig =
-                  if name == nme.CONSTRUCTOR && sym.exists && sym.owner.is(JavaAnnotation) then Signature.NotAMethod
+                  if name == nme.CONSTRUCTOR && tree.symbol.exists && tree.symbol.owner.is(JavaAnnotation) then Signature.NotAMethod
                   else tree.tpe.signature
-                var ename = sym.targetName
+                var ename = tree.symbol.targetName
                 val selectFromQualifier =
                   name.isTypeName
                   || qual.isInstanceOf[Hole] // holes have no symbol
                   || sig == Signature.NotAMethod // no overload resolution necessary
-                  || !sym.exists // polymorphic function type
+                  || !tree.denot.symbol.exists // polymorphic function type
                   || tree.denot.asSingleDenotation.isRefinedMethod // refined methods have no defining class symbol
                 if selectFromQualifier then
                   writeByte(if name.isTypeName then SELECTtpt else SELECT)
@@ -493,9 +491,9 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
                 else // select from owner
                   writeByte(SELECTin)
                   withLength {
-                    pickleNameAndSig(name, sym.signature, ename)
+                    pickleNameAndSig(name, tree.symbol.signature, ename)
                     pickleTree(qual)
-                    pickleType(sym.owner.typeRef)
+                    pickleType(tree.symbol.owner.typeRef)
                   }
               else
                 writeByte(if name.isTypeName then SELECTtpt else SELECT)

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3416,7 +3416,7 @@ extends DeclarationMsg(IllegalUnrollPlacementID):
     case Some(method) =>
       val isCtor = method.isConstructor
       def what = if isCtor then i"a ${if method.owner.is(Trait) then "trait" else "class"} constructor" else i"method ${method.name}"
-      val prefix = s"Can not unroll parameters of $what"
+      val prefix = s"Cannot unroll parameters of $what"
       if method.is(Deferred) then
         i"$prefix: it must not be abstract"
       else if isCtor && method.owner.is(Trait) then

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -120,20 +120,12 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
 
     private var inJavaAnnot: Boolean = false
 
-    private var seenUnrolledMethods: util.EqHashMap[Symbol, Boolean] | Null = null
+    private val seenUnrolledMethods: util.EqHashMap[Symbol, Boolean] = new util.EqHashMap[Symbol, Boolean]
 
     private var noCheckNews: Set[New] = Set()
 
     def isValidUnrolledMethod(method: Symbol, origin: SrcPos)(using Context): Boolean =
-      val seenMethods =
-        val local = seenUnrolledMethods
-        if local == null then
-          val map = new util.EqHashMap[Symbol, Boolean]
-          seenUnrolledMethods = map
-          map
-        else
-          local
-      seenMethods.getOrElseUpdate(method, {
+      seenUnrolledMethods.getOrElseUpdate(method, {
         val isCtor = method.isConstructor
         if
           method.name.is(DefaultGetterName)
@@ -234,12 +226,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
     private def registerIfUnrolledParam(sym: Symbol)(using Context): Unit =
       if sym.hasAnnotation(defn.UnrollAnnot) && isValidUnrolledMethod(sym.owner, sym.sourcePos) then
         val cls = sym.enclosingClass
-        val classes = ctx.compilationUnit.unrolledClasses
         val additions = Array(cls, cls.linkedClass).filter(_ != NoSymbol)
-        if classes == null then
-          ctx.compilationUnit.unrolledClasses = Set.from(additions)
-        else
-          ctx.compilationUnit.unrolledClasses = classes ++ additions
+        ctx.compilationUnit.unrolledClasses ++= additions
 
     private def processValOrDefDef(tree: Tree)(using Context): tree.type =
       val sym = tree.symbol